grpc_kit 0.1.0 → 0.1.1

data/lib/grpc_kit/session/server.rb

@@ -1,31 +1,52 @@
 # frozen_string_literal: true
 
+require 'forwardable'
 require 'ds9'
 require 'grpc_kit/session/stream'
 
 module GrpcKit
   module Session
     class Server < DS9::Server
-      # @io [GrpcKit::IO::XXX]
+      extend Forwardable
+
+      delegate %i[send_event recv_event] => :@io
+
+      # @params io [GrpcKit::Session::IO]
       def initialize(io, handler)
-        super() # initialize DS9::Server
+        super() # initialize DS9::Session
 
         @io = io
         @streams = {}
         @stop = false
         @handler = handler
+        @peer_shutdowned = false
+        @inflights = []
       end
 
       def start
         @io.wait_readable
-        until @stop && (want_read? || want_write?)
-          if want_write?
-            send
-          end
+        loop do
+          invoke_handler
 
-          if want_read?
-            receive
+          if !want_read? && !want_write?
+            break
+          elsif @peer_shutdowned && !want_write?
+            break
           end
+
+          run_once
+        end
+      end
+
+      def run_once
+        return if @stop
+
+        if want_read?
+          do_read
+        end
+
+        if want_write?
+          send
         end
       end
 
@@ -33,79 +54,103 @@ module GrpcKit
         @stop = true
       end
 
+      def finish
+        stop
+        @io.close
+      end
+
       private
 
-      # provider for nghttp2_submit_response
-      # override
+      def invoke_handler
+        while (stream = @inflights.pop)
+          @handler.dispatch(stream, self)
+        end
+      end
+
+      def do_read
+        receive
+      rescue IOError => e
+        finish
+        raise e
+      rescue DS9::Exception => e
+        finish
+        if DS9::ERR_EOF == e.code
+          @peer_shutdowned = true
+          return
+          # raise EOFError
+        end
+
+        raise e
+      end
+
+      # `provider` for nghttp2_submit_response
       def on_data_source_read(stream_id, length)
         GrpcKit.logger.debug("on_data_source_read #{stream_id}, lenght=#{length}")
 
-        data = @streams[stream_id].read(length)
-        if data.nil?
+        stream = @streams[stream_id]
+        data = @streams[stream_id].pending_send_data.read(length)
+        if data.empty? && stream.end_write?
+          # TODO
           submit_trailer(stream_id, 'grpc-status' => '0')
-          false # nil mean END_STREAM
+
+          false # means EOF and END_STREAM
         else
           data
         end
       end
 
-      # for nghttp2_session_callbacks_set_send_callback
-      # override
-      def send_event(string)
-        GrpcKit.logger.debug('send_event')
-
-        @io.write(string)
-      end
-
-      # for nghttp2_session_callbacks_set_recv_callback
-      # override
-      def recv_event(length)
-        # GrpcKit.logger.debug("recv_event #{length}")
-        @io.read(length)
-      end
-
-      # for nghttp2_session_callbacks_set_on_frame_send_callback
+      # nghttp2_session_callbacks_set_on_frame_recv_callback
       def on_frame_recv(frame)
         GrpcKit.logger.debug("on_frame_recv #{frame}")
+
         case frame
         when DS9::Frames::Data
-          # need to port NGHTTP2_FLAG_END_STREAM to check frame.flag has it
+
           stream = @streams[frame.stream_id]
-          resp = @handler.on_frame_data_recv(stream)
-          unless resp
-            return # TODO
+
+          if frame.end_stream?
+            stream.remote_end_stream = true
           end
 
-          submit_response(
-            frame.stream_id,
-            ':status' => '200',
-            'content-type' => 'application/grpc',
-            'accept-encoding' => 'identity,gzip',
-          )
-        # when DS9::Frames::Headers
-        # need to port NGHTTP2_FLAG_END_STREAM to check frame.flag has it
-        # when DS9::Frames::Goaway
-        # when DS9::Frames::RstStream
-        else
-          GrpcKit.logger.info("unsupport frame #{frame}")
+          unless stream.inflight
+            stream.inflight = true
+            @inflights << stream
+          end
+        when DS9::Frames::Headers
+          stream = @streams[frame.stream_id]
+
+          if frame.end_stream?
+            stream.remote_end_stream = true
+          end
+
+          # when DS9::Frames::Goaway
+          # when DS9::Frames::RstStream
         end
 
         true
       end
 
-      # for nghttp2_session_callbacks_set_on_frame_send_callback
+      # nghttp2_session_callbacks_set_on_frame_send_callback
       def on_frame_send(frame)
         GrpcKit.logger.debug("on_frame_send #{frame}")
+        case frame
+        when DS9::Frames::Data, DS9::Frames::Headers
+          stream = @streams[frame.stream_id]
+          if frame.end_stream?
+            stream.local_end_stream = true
+          end
+        end
+
         true
       end
 
-      # for nghttp2_session_callbacks_set_on_frame_not_send_callback
+      # nghttp2_session_callbacks_set_on_frame_not_send_callback
       def on_frame_not_send(frame, reason)
         GrpcKit.logger.debug("on_frame_not_send frame=#{frame}, reason=#{reason}")
         true
       end
 
-      # for nghttp2_session_callbacks_set_on_begin_headers_callback
+      # nghttp2_session_callbacks_set_on_begin_headers_callback
       def on_begin_headers(header)
         stream_id = header.stream_id
         GrpcKit.logger.debug("on_begin_header stream_id=#{stream_id}")
@@ -117,38 +162,32 @@ module GrpcKit
         @streams[stream_id] = GrpcKit::Session::Stream.new(stream_id: stream_id)
       end
 
-      # for nghttp2_session_callbacks_set_on_header_callback
+      # nghttp2_session_callbacks_set_on_header_callback
       def on_header(name, value, frame, _flags)
-        @streams[frame.stream_id].headers[name] = value
-      end
-
-      # for nghttp2_session_callbacks_set_on_begin_frame_callback
-      def on_begin_frame(frame_header)
-        GrpcKit.logger.debug("on_begin_frame #{frame_header}")
-        true
+        stream = @streams[frame.stream_id]
+        stream.add_header(name, value)
       end
 
-      # for nghttp2_session_callbacks_set_on_invalid_frame_recv_callback
       def on_invalid_frame_recv(frame, error_code)
-        GrpcKit.logger.debug("on_invalid_frame_recv #{error_code}")
+        GrpcKit.logger.debug("on_invalid_frame_recv #{frame} error_code=#{error_code}")
         true
       end
 
-      # for nghttp2_session_callbacks_set_on_stream_close_callback
+      # nghttp2_session_callbacks_set_on_stream_close_callback
       def on_stream_close(stream_id, error_code)
         GrpcKit.logger.debug("on_stream_close stream_id=#{stream_id}, error_code=#{error_code}")
-        @streams.delete(stream_id)
-      end
+        stream = @streams.delete(stream_id)
+        return unless stream
 
-      # for nghttp2_session_callbacks_set_on_data_chunk_recv_callback
-      def on_data_chunk_recv(stream_id, data, _flags)
-        @handler.on_data_chunk_recv(@streams[stream_id], data)
+        stream.end_stream
       end
 
-      # nghttp2_session_callbacks_set_before_frame_send_callback
-      def before_frame_send(frame)
-        GrpcKit.logger.debug("before_frame_send frame=#{frame}")
-        true
+      # nghttp2_session_callbacks_set_on_data_chunk_recv_callback
+      def on_data_chunk_recv(stream_id, data, _flags)
+        stream = @streams[stream_id]
+        if stream
+          stream.pending_recv_data.write(data)
+        end
       end
     end
   end

data/lib/grpc_kit/session/stream.rb

@@ -1,67 +1,59 @@
 # frozen_string_literal: false
 
-require 'ds9'
+require 'forwardable'
+require 'grpc_kit/session/buffer'
+require 'grpc_kit/session/headers'
 
 module GrpcKit
   module Session
     class Stream
-      attr_reader :headers
-      attr_accessor :data
+      extend Forwardable
 
-      def initialize(stream_id:, end_read_stream: false, end_write_stream: false)
-        @stream_id = stream_id
-        @end_read_stream = end_read_stream
-        @end_write_stream = end_write_stream
-        @end_stream = false
-        @headers = {}
-
-        @data = ''
-        @write_data = StringIO.new
-      end
+      delegate end_write: :@pending_send_data
+      delegate end_read: :@pending_recv_data
 
-      def close
-        @end_stream = true
-      end
+      attr_reader :headers, :pending_send_data, :pending_recv_data
+      attr_accessor :local_end_stream, :remote_end_stream, :inflight, :stream_id
 
-      def closed?
-        @end_stream
-      end
+      def initialize(stream_id:, send_data: GrpcKit::Session::Buffer.new)
+        @stream_id = stream_id
+        @end_read_stream = false
+        @headers = GrpcKit::Session::Headers.new
+        @pending_send_data = send_data
+        @pending_recv_data = GrpcKit::Session::Buffer.new
 
-      def eq?(stream_id)
-        @stream_id == stream_id
+        @local_end_stream = false
+        @remote_end_stream = false
+        @inflight = false
       end
 
-      def exist_data?
-        !@data.empty?
+      def write_send_data(data, last: false)
+        @pending_send_data.write(data, last: last)
       end
 
-      def recv(data)
-        @data = data # XXX
+      def read_recv_data(last: false)
+        @pending_recv_data.read(last: last)
       end
 
-      # TODO
-      def recv2(data)
-        @data << data
+      def end_write?
+        @local_end_stream || @pending_send_data.end_write?
       end
 
-      # TODO: name
-      def send(data)
-        @write_data = data
-        # @write_data.write(data)
+      def end_read?
+        @remote_end_stream || @pending_recv_data.end_read?
       end
 
-      # TODO: name
-      def read(len)
-        # @write_data.rewind
-        @write_data.read(len)
+      def end_stream?
+        end_read? && end_write?
       end
 
-      def read_stream_end?
-        @end_read_stream
+      def end_stream
+        end_read
+        end_write
       end
 
-      def write_stream_end?
-        @end_write_stream
+      def add_header(name, value)
+        @headers.add(name, value)
       end
     end
   end

data/lib/grpc_kit/stream.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'grpc_kit/streams/packable'
+
+module GrpcKit
+  class Stream
+    include GrpcKit::Streams::Packable
+
+    extend Forwardable
+
+    delegate %i[stream_id end_write end_read end_write? end_read?] => :@stream
+
+    # @params protobuf [GrpcKit::Protobuffer]
+    # @params session [GrpcKit::Session::Server|GrpcKit::Session::Client]
+    # @params stream [GrpcKit::Session::Stream] primitive H2 stream id
+    def initialize(protobuf:, session:, stream:)
+      @protobuf = protobuf
+      @session = session
+      @stream = stream
+    end
+
+    def each
+      loop { yield(recv) }
+    end
+
+    def send(data, last: false)
+      req = @protobuf.encode(data)
+      @stream.write_send_data(pack(req), last: last)
+    end
+
+    def recv(last: false)
+      data = unpack(read(last: last))
+
+      unless data
+        raise StopIteration
+      end
+
+      compressed, size, buf = *data
+
+      unless size == buf.size
+        raise "inconsistent data: #{buf}"
+      end
+
+      if compressed
+        raise 'compress option is unsupported'
+      end
+
+      @protobuf.decode(buf)
+    end
+
+    private
+
+    def read(last: false)
+      loop do
+        data = @stream.read_recv_data(last: last)
+        if data.empty?
+          # Consider `end_read` is set in this invocation
+          if @stream.end_read? && !last
+            return nil
+          end
+
+          @session.run_once
+          redo
+        end
+
+        return data
+      end
+    end
+  end
+end

data/lib/grpc_kit/streams/client.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'grpc_kit/stream'
+require 'grpc_kit/streams/send_buffer'
+
+module GrpcKit
+  module Streams
+    class Client
+      def initialize(path:, protobuf:, session:, authority:)
+        @path = path
+        @session = session
+        @protobuf = protobuf
+        @stream = nil
+        @authority = authority
+      end
+
+      def send_msg(data, metadata: {}, timeout: nil, last: false)
+        if @stream
+          unless @stream.end_write?
+            @session.resume_data(@stream.stream_id)
+          end
+        else
+          headers = build_headers(metadata: metadata, timeout: timeout)
+          stream = @session.start_request(GrpcKit::Streams::SendBuffer.new, headers)
+          @stream = GrpcKit::Stream.new(protobuf: @protobuf, session: @session, stream: stream)
+        end
+
+        @stream.send(data, last: last)
+        @session.run_once
+      end
+
+      def each(&block)
+        unless @stream
+          raise 'You should call `send` method to send data'
+        end
+
+        @stream.each(&block)
+      end
+
+      def recv(last: false)
+        unless @stream
+          raise 'You should call `send` method to send data'
+        end
+
+        @stream.recv(last: last)
+      end
+
+      def close_and_recv
+        unless @stream
+          raise 'You should call `send` method to send data'
+        end
+
+        unless @stream.end_write?
+          @session.resume_data(@stream.stream_id)
+        end
+
+        @stream.end_write
+        @session.start(@stream.stream_id)
+        @stream.end_read
+
+        data = []
+        @stream.each { |d| data.push(d) }
+        data
+      end
+
+      private
+
+      def build_headers(metadata: {}, timeout: nil, **headers)
+        hdrs = metadata.merge(headers).merge(
+          ':method' => 'POST',
+          ':scheme' => 'http',
+          ':path' => @path,
+          ':authority' => @authority,
+          'te' => 'trailers',
+          'content-type' => 'application/grpc',
+          'user-agent' => "grpc-ruby/#{GrpcKit::VERSION} (grpc_kit)",
+          'grpc-accept-encoding' => 'identity,deflate,gzip',
+        )
+        if timeout
+          hdrs['grpc-timeout'] = timeout
+        end
+
+        hdrs
+      end
+    end
+  end
+end