grpc_kit 0.1.0 → 0.1.1

data/lib/grpc_kit/session/buffer.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module GrpcKit
+  module Session
+    class Buffer
+      attr_accessor :finish
+
+      def initialize(buffer: nil)
+        @buffer = buffer
+        @end_read = false
+        @end_write = false
+        @finish = false
+        @write_byte_size = 0
+      end
+
+      def write(data, last: false)
+        end_write if last
+        @write_byte_size += data.size
+
+        if @buffer
+          @buffer << data
+        else
+          @buffer = data
+        end
+      end
+
+      def read(len = nil, last: false)
+        end_read if last
+
+        if @buffer.nil?
+          return ''
+        end
+
+        if len
+          @buffer.slice!(0...len)
+        else
+          @buffer.slice!(0..-1)
+        end
+      end
+
+      def end_read?
+        @end_read
+      end
+
+      def end_write?
+        @end_write
+      end
+
+      def end_read
+        @end_read = true
+      end
+
+      def end_write
+        @end_write = true
+      end
+    end
+  end
+end

data/lib/grpc_kit/session/client.rb

@@ -1,75 +1,140 @@
 # frozen_string_literal: true
 
+require 'forwardable'
 require 'ds9'
 require 'grpc_kit/session/stream'
 
 module GrpcKit
   module Session
     class Client < DS9::Client
-      # @io [GrpcKit::IO::XXX]
-      def initialize(io, handler)
+      extend Forwardable
+
+      delegate %i[send_event recv_event] => :@io
+
+      # @params io [GrpcKit::Session::IO]
+      def initialize(io, handler, opts = {})
         super() # initialize DS9::Session
 
         @io = io
         @streams = {}
         @handler = handler
+        @opts = opts
       end
 
-      def start(stream_id)
-        stream = GrpcKit::Session::Stream.new(stream_id: stream_id)
+      def start_request(data, headers)
+        stream_id = submit_request(headers, data)
+        stream = GrpcKit::Session::Stream.new(stream_id: stream_id, send_data: data)
+        stream.stream_id = stream_id
         @streams[stream_id] = stream
+        stream
+      end
 
-        while want_read? || want_write?
-          if stream.closed?
-            break
-          elsif !stream.exist_data?
-            receive
+      def start(stream_id)
+        stream = @streams.fetch(stream_id)
 
-            send
-          else
+        loop do
+          if (!want_read? && !want_write?) || stream.end_stream?
             break
-            # GrpcKit.logger.info("unknown #{stream}")
           end
+
+          run_once
+        end
+      end
+
+      def run_once
+        return if @stop
+
+        if want_read?
+          do_read
+        end
+
+        if want_write?
+          send
         end
-        # invalid if receive and send are not called
       end
 
       private
 
-      # for nghttp2_session_callbacks_set_send_callback
-      # override
-      def send_event(string)
-        @io.write(string)
+      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
 
-      # for nghttp2_session_callbacks_set_recv_callback
-      # override
-      def recv_event(length)
-        @io.read(length)
+      # nghttp2_session_callbacks_set_on_frame_send_callback
+      def on_frame_recv(frame)
+        GrpcKit.logger.debug("on_frame_recv #{frame}")
+        case frame
+        when DS9::Frames::Data
+          stream = @streams[frame.stream_id]
+
+          if frame.end_stream?
+            stream.remote_end_stream = true
+          end
+
+          unless stream.inflight
+            stream.inflight = true
+          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_data_chunk_recv_callback
-      def on_data_chunk_recv(stream_id, data, flags)
-        @handler.on_data_chunk_recv(@streams[stream_id], data)
+      # 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
 
-      # provider for nghttp2_submit_response
-      # def on_data_source_read(stream_id, length)
-      # end
+      # 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}")
+        stream = @streams.delete(stream_id)
+        return unless stream
 
-      # for nghttp2_session_callbacks_set_on_frame_send_callback
-      # def on_frame_recv(frame)
-      #   GrpcKit.logger.debug("on_frame_recv #{frame}")
-      # end
+        stream.end_stream
+      end
+
+      # 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
 
       # # for nghttp2_session_callbacks_set_on_frame_not_send_callback
       # def on_frame_not_send(frame, reason)
       # end
 
-      # # for nghttp2_session_callbacks_set_on_frame_send_callback
-      # def on_frame_send(frame, reason)
-      # end
-
       # # for nghttp2_session_callbacks_set_on_header_callback
       # def on_header(name, value, frame, flags)
       # end
@@ -85,23 +150,6 @@ module GrpcKit
       # # for nghttp2_session_callbacks_set_on_invalid_frame_recv_callback
       # def on_invalid_frame_recv(frame, error_code)
       # end
-
-      # for 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}")
-        stream = @streams.delete(stream_id)
-        if stream
-          stream.close
-        end
-      end
-
-      # # for nghttp2_session_callbacks_set_on_data_chunk_recv_callback
-      # def on_data_chunk_recv(id, data, flags)
-      # end
-
-      # # nghttp2_session_callbacks_set_before_frame_send_callback
-      # def before_frame_send(frame)
-      # end
     end
   end
 end

data/lib/grpc_kit/session/duration.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module GrpcKit
+  module Session
+    class Duration < Struct.new(:sec, :msec, :usec, :nsec)
+      MAX_TIMEOUT = 10**9 - 1
+      HOUR = 60 * 60
+      MIN = 60
+      MILL_SEC = 10**-3
+      MICRO_SEC = 10**-6
+      NANO_SEC = 10**-9
+
+      # @params val [String]
+      def self.decode(value)
+        size = value.size
+        if size < 2
+          raise "Invalid format: too short #{value}"
+        end
+
+        unit = value[(size - 1)..size]
+        d = Duration.new(0, 0, 0, 0)
+        n = Integer(value[0..size])
+
+        case u
+        when 'H'
+          d.sec = n * HOUR
+        when 'M'
+          d.sec = n * MIN
+        when 'S'
+          d.sec = n
+        when 'm'
+          d.msec = n
+        when 'u'
+          d.usec = n
+        when 'n'
+          d.nsec = n
+        else
+          raise "Invalid unit `#{u}`: #{unit} "
+        end
+        d
+      end
+
+      def to_timeout
+        v = 0
+
+        if nsec && (nsec != 0)
+          v += (NANO_SEC * nsec)
+        end
+
+        if usec && (usec != 0)
+          v += (MICRO_SEC * usec)
+        end
+
+        if msec && (msec != 0)
+          v += (MILL_SEC * msec)
+        end
+
+        if sec
+          v += sec
+        end
+
+        v
+      end
+
+      # @params val [Numeric]
+      def self.from_numeric(val)
+        case val
+        when nil
+        when Numeric
+          if val < 0
+            Duration.new(MAX_TIMEOUT, 0, 0, 0)
+          elsif val == 0
+            Duration.new(0, 0, 0, 0)
+          else
+            Duration.new(val, 0, 0, 0)
+          end
+        else
+          raise "Cannot make timeout from #{val}"
+        end
+      end
+
+      # TODO
+      def to_s
+        if nsec && (nsec != 0)
+          "#{nsec}n"
+        elsif usec && (usec != 0)
+          "#{usec}u"
+        elsif msec && (msec != 0)
+          "#{msec}m"
+        elsif sec
+          "#{sec}S"
+        end
+      end
+    end
+  end
+end

data/lib/grpc_kit/session/headers.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'grpc_kit/session/duration'
+
+module GrpcKit
+  module Session
+    Headers = Struct.new(
+      :metadata,
+      :path,
+      :grpc_encoding,
+      :grpc_status,
+      :status_message,
+      :timeout,
+      :method,
+      :http_status,
+    ) do
+
+      RESERVED_HEADERS = [
+        'content-type',
+        'user-agent',
+        'grpc-message-type',
+        'grpc-encoding',
+        'grpc-message',
+        'grpc-status',
+        'grpc-status-details-bin',
+        'te'
+      ].freeze
+
+      METADATA_ACCEPTABLE_HEADER = %w[authority user-agent].freeze
+      def initialize
+        super({}) # set metadata empty hash
+      end
+
+      def add(key, val)
+        case key
+        when ':path'
+          self.path = val
+        when ':status'
+          self.http_status = val.to_i
+        when 'content-type'
+          # TODO
+          metadata[key] = val
+        when 'grpc-encoding'
+          self.grpc_encoding = val
+        when 'grpc-status'
+          self.grpc_status = val.to_i
+        when 'grpc-timeout'
+          self.timeout = Duration.decod(v)
+        when 'grpc-message'
+          # TODO
+          GrpcKit.logger.warn('grpc-message is unsupported header now')
+        when 'grpc-status-details-bin'
+          # TODO
+          GrpcKit.logger.warn('grpc-status-details-bin is unsupported header now')
+        else
+          if RESERVED_HEADERS.include?(key) && !METADATA_ACCEPTABLE_HEADER.include?(key)
+            return
+          end
+
+          metadata[key] = val
+        end
+      end
+    end
+  end
+end

data/lib/grpc_kit/session/io.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'ds9'
+
+module GrpcKit
+  module Session
+    class IO
+      def initialize(io)
+        @io = io
+      end
+
+      def close
+        @io.close
+      end
+
+      def recv_event(length)
+        data = @io.read_nonblock(length, nil, exception: false)
+
+        case data
+        when :wait_readable
+          DS9::ERR_WOULDBLOCK
+        when nil # nil means EOF
+          DS9::ERR_EOF
+        else
+          data
+        end
+      end
+
+      def send_event(data)
+        remain = data.bytesize
+        size = remain
+        while remain > 0
+          begin
+            remain -= @io.syswrite(data)
+          rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+            unless IO.select(nil, [io], nil, 1)
+              raise 'timeout writing data'
+            end
+          end
+
+          data = data.byteslice(remain..-1)
+        end
+
+        size
+      end
+
+      def wait_readable
+        @io.wait_writable
+      end
+
+      def flush
+        @io.flush
+      end
+    end
+  end
+end