grpc_kit 0.1.3 → 0.1.4

data/lib/grpc_kit/rpcs/request_response.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require 'grpc_kit/rpcs/base'
-require 'grpc_kit/status_codes'
-
-module GrpcKit
-  module Rpcs
-    module Client
-      class RequestResponse < Base
-        def invoke(session, request, authority:, metadata: {}, timeout: nil, **opts)
-          cs = GrpcKit::Streams::Client.new(config: @config, session: session, authority: authority)
-
-          call = GrpcKit::Rpcs::Call.new(metadata, @config.method_name, @config.service_name, cs)
-          @config.interceptor.intercept(request, call, metadata) do |r, c, m|
-            if timeout
-              # XXX: when timeout.to_timeout is 0
-              Timeout.timeout(timeout.to_timeout, GrpcKit::Errors::DeadlineExceeded) do
-                c.send_msg(r, timeout: timeout.to_s, metadata: m, last: true)
-                c.recv(last: true)
-              end
-            else
-              c.send_msg(r, metadata: m, last: true)
-              c.recv(last: true)
-            end
-          end
-        end
-      end
-    end
-
-    module Server
-      class RequestResponse < Base
-        def invoke(stream, session)
-          ss = GrpcKit::Streams::Server.new(stream: stream, session: session, config: @config)
-          call = GrpcKit::Rpcs::Call.new(stream.headers.metadata, @config.method_name, @config.service_name, ss)
-
-          begin
-            do_invoke(ss, call)
-          rescue GrpcKit::Errors::BadStatus => e
-            ss.send_status(status: e.code, msg: e.reason, metadata: {}) # TODO: metadata should be set
-          rescue StandardError => e
-            ss.send_status(status: GrpcKit::StatusCodes::UNKNOWN, msg: e.message, metadata: {})
-          end
-        end
-
-        private
-
-        def do_invoke(ss, call)
-          request = ss.recv(last: true)
-
-          resp =
-            if @config.interceptor
-              @config.interceptor.intercept(request, call) do |req, c|
-                @handler.send(@config.ruby_style_method_name, req, c)
-              end
-            else
-              @handler.send(@config.ruby_style_method_name, request, call)
-            end
-
-          ss.send_msg(resp, last: true)
-        end
-      end
-    end
-  end
-end

data/lib/grpc_kit/rpcs/server_streamer.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'grpc_kit/rpcs/base'
-
-module GrpcKit
-  module Rpcs
-    module Client
-      class ServerStreamer < Base
-        def invoke(session, request, authority:, metadata: {}, timeout: nil, **opts)
-          cs = GrpcKit::Streams::Client.new(config: @config, session: session, authority: authority)
-          call = GrpcKit::Rpcs::Call.new(metadata, @config.method_name, @config.service_name, cs)
-
-          @config.interceptor.intercept(call, metadata) do |c, m|
-            c.send_msg(request, metadata: m, last: true)
-            c
-          end
-        end
-      end
-    end
-
-    module Server
-      class ServerStreamer < Base
-        def invoke(stream, session)
-          ss = GrpcKit::Streams::Server.new(stream: stream, session: session, config: @config)
-          call = GrpcKit::Rpcs::Call.new(stream.headers.metadata, @config.method_name, @config.service_name, ss)
-
-          if @config.interceptor
-            @config.interceptor.intercept(call) do |c|
-              request = c.recv(last: true)
-              @handler.send(@config.ruby_style_method_name, request, c)
-            end
-          else
-            request = call.recv(last: true)
-            @handler.send(@config.ruby_style_method_name, request, call)
-          end
-
-          ss.send_trailer
-        end
-      end
-    end
-  end
-end

data/lib/grpc_kit/session/duration.rb

@@ -1,97 +0,0 @@
-# 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)
-        value = value.dup
-        size = value.size
-        if size < 2
-          raise "Invalid format: too short #{value}"
-        end
-
-        unit = value.slice!(-1, 1)
-        d = Duration.new(0, 0, 0, 0)
-        n = Integer(value)
-
-        case unit
-        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 `#{unit}`: #{value + 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/stream.rb

@@ -1,120 +0,0 @@
-# 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? close_remote? headers] => :@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 do
-        data = recv
-        return if data.nil?
-
-        yield(data)
-      end
-    end
-
-    def send(data, last: false, limit_size: nil)
-      b =
-        begin
-          @protobuf.encode(data)
-        rescue ArgumentError => e
-          raise GrpcKit::Errors::Internal, "Error while encoding: #{e}"
-        end
-
-      req = pack(b)
-      if limit_size && req.bytesize > limit_size
-        raise GrpcKit::Errors::ResourceExhausted, "Sending message is too large: send=#{req.bytesize}, max=#{limit_size}"
-      end
-
-      @stream.write_send_data(req, last: last)
-    end
-
-    def recv(last: false, limit_size: nil)
-      data = unpack(read(last: last))
-
-      return nil unless data
-
-      compressed, size, buf = *data
-
-      unless size == buf.size
-        raise "inconsistent data: #{buf}"
-      end
-
-      if limit_size && size > limit_size
-        raise GrpcKit::Errors::ResourceExhausted, "Receving message is too large: recevied=#{size}, max=#{limit_size}"
-      end
-
-      if compressed
-        raise 'compress option is unsupported'
-      end
-
-      begin
-        @protobuf.decode(buf)
-      rescue ArgumentError => e
-        raise GrpcKit::Errors::Internal, "Error while decoding #{e}"
-      end
-    end
-
-    def send_trailer(status: GrpcKit::StatusCodes::OK, msg: nil, metadata: {})
-      trailer = metadata.dup
-      trailer['grpc-status'] = status.to_s
-      if msg
-        trailer['grpc-message'] = msg
-      end
-
-      @stream.write_trailers_data(trailer)
-      @stream.end_write
-    end
-
-    # TODO: use actual data
-    def submit_response(_header = nil, piggyback_trailer: false)
-      headers = { ':status' => '200', 'content-type' => 'application/grpc' }
-
-      # ds9 does not support nthttp2_submit_{response|request} without body
-      # if piggyback_trailer
-      #   headers.merge!(@stream.trailer_data)
-      #   @stream.need_trailer = false
-      # else
-      headers['accept-encoding'] = 'identity'
-      # end
-
-      @session.submit_response(@stream.stream_id, headers)
-    end
-
-    private
-
-    def read(last: false)
-      loop do
-        data = @stream.read_recv_data(last: last)
-        return data unless data.empty?
-
-        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
-
-          return nil
-        end
-
-        @session.run_once
-      end
-    end
-  end
-end

data/lib/grpc_kit/streams/client.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require 'grpc_kit/stream'
-require 'grpc_kit/streams/send_buffer'
-require 'grpc_kit/status_codes'
-
-module GrpcKit
-  module Streams
-    class Client
-      def initialize(session:, config:, authority:)
-        @config = config
-        @session = session
-        @stream = nil
-        @authority = authority
-      end
-
-      def send_msg(data, metadata: {}, timeout: nil, last: false)
-        if @stream
-          # unless metadata.empty?
-          #   raise 'You can attach metadata at first send_msg' # XXX
-          # end
-
-          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: @config.protobuf, session: @session, stream: stream)
-        end
-
-        @stream.send(data, last: last, limit_size: @config.max_send_message_size)
-        @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
-
-        data = @stream.recv(last: last, limit_size: @config.max_receive_message_size)
-
-        if data.nil?
-          check_status!
-          raise StopIteration
-        end
-
-        data
-      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
-
-        check_status!
-
-        data = []
-        @stream.each { |d| data.push(d) }
-        data
-      end
-
-      private
-
-      def check_status!
-        # XXX: wait until half close (remote) to get grpc-status
-        until @stream.close_remote?
-          @session.run_once
-        end
-
-        if @stream.headers.grpc_status != GrpcKit::StatusCodes::OK
-          raise GrpcKit::Errors.from_status_code(@stream.headers.grpc_status, @stream.headers.status_message)
-        else
-          GrpcKit.logger.debug('request is success')
-        end
-      end
-
-      def build_headers(metadata: {}, timeout: nil, **headers)
-        hdrs = metadata.merge(headers).merge(
-          ':method' => 'POST',
-          ':scheme' => 'http',
-          ':path' => @config.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

data/lib/grpc_kit/streams/server.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-require 'grpc_kit/stream'
-require 'grpc_kit/status_codes'
-
-module GrpcKit
-  module Streams
-    class Server
-      extend Forwardable
-
-      delegate %i[each recv] => :@stream
-
-      def initialize(stream:, session:, config:)
-        @stream = GrpcKit::Stream.new(protobuf: config.protobuf, session: session, stream: stream)
-        @config = config
-        @sent_first_msg = false
-      end
-
-      def send_msg(data, last: false)
-        if last
-          @stream.send_trailer # TODO: pass trailer metadata
-        end
-
-        @stream.send(data, last: last, limit_size: @config.max_send_message_size)
-        return if @sent_first_msg
-
-        @stream.submit_response
-        @sent_first_msg = true
-      end
-
-      def recv(last: false)
-        data = @stream.recv(last: last, limit_size: @config.max_receive_message_size)
-        raise StopIteration if data.nil?
-
-        data
-      end
-
-      def send_trailer
-        @stream.send_trailer # TODO: pass trailer metadata
-        @stream.end_write
-      end
-
-      def send_status(status: GrpcKit::StatusCodes::INTERNAL, msg: nil, metadata: {})
-        @stream.send_trailer(status: status, msg: msg, metadata: metadata)
-        return if @sent_first_msg
-
-        @stream.submit_response(piggyback_trailer: true)
-        @sent_first_msg = true
-      end
-    end
-  end
-end