grpc_kit 0.1.0

data/lib/grpc_kit/grpc/dsl.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'grpc_kit/errors'
+require 'grpc_kit/rpc_desc'
+require 'grpc_kit/client'
+require 'grpc_kit/grpc/stream'
+
+module GrpcKit
+  module GRPC
+    module Dsl
+      attr_accessor :service_name
+
+      attr_writer :marshal_class_method, :unmarshal_class_method
+
+      def inherited(subclass)
+        subclass.rpc_descs.merge!(rpc_descs)
+        subclass.service_name = service_name
+      end
+
+      def rpc(name, input, output)
+        if rpc_descs.key?(name)
+          raise "rpc (#{name}) is already defined"
+        end
+
+        unless input.respond_to?(@marshal_class_method)
+          raise "#{marshal} must implement #{marshal}.#{@marshal_class_method}"
+        end
+
+        unless output.respond_to?(@unmarshal_class_method)
+          raise "#{unmarshal} must implement #{unmarshal}.#{@unmarshal_class_method}"
+        end
+
+        # create StreamDesc?
+        rpc_descs[name] = GrpcKit::RpcDesc.new(
+          name: name,
+          input: input,
+          output: output,
+          marshal_method: @marshal_class_method,
+          unmarshal_method: @unmarshal_class_method,
+        )
+
+        define_method(rpc_descs[name].ruby_style_name) do |_, _|
+          raise GrpcKit::Errors::Unimplemented, name.to_s
+        end
+      end
+
+      def stream(cls)
+        GrpcKit::GRPC::Stream.new(cls)
+      end
+
+      def rpc_stub_class
+        rpc_descs_ = rpc_descs
+        service_name_ = service_name
+        Class.new(GrpcKit::Client) do
+          rpc_descs_.each_pair do |_, rpc_desc|
+            method_name = rpc_desc.ruby_style_name
+            path = rpc_desc.path(service_name_)
+
+            if rpc_desc.request_response?
+              define_method(method_name) do |request, opts = {}|
+                request_response(path, request, rpc_desc, opts)
+              end
+            elsif rpc_desc.client_streamer?
+              define_method(method_name) do |requests, opts = {}|
+                client_streamer(path, requests, rpc_desc, opts)
+              end
+            elsif rpc_desc.server_streamer?
+              define_method(method_name) do |request, opts = {}, &blk|
+                server_streamer(path, request, rpc_desc, opts, &blk)
+              end
+            elsif rpc_desc.bidi_streamer?
+              define_method(method_name) do |requests, opts = {}, &blk|
+                bidi_streamer(path, requests, rpc_desc, opts, &blk)
+              end
+            else
+              raise "unknown #{rpc_desc}"
+            end
+          end
+        end
+      end
+
+      def rpc_descs
+        @rpc_descs ||= {}
+      end
+    end
+  end
+end

data/lib/grpc_kit/grpc/generic_service.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'grpc_kit/grpc/dsl'
+
+module GrpcKit
+  module GRPC
+    module GenericService
+      def self.included(obj)
+        obj.extend(GrpcKit::GRPC::Dsl)
+        return unless obj.service_name.nil?
+
+        # if obj.name.nil?
+        #   obj.service_name = 'GenericService'
+        # else
+        # modules = obj.name.split('::')
+        # obj.service_name =
+        #   if modules.length > 2
+        #     modules[modules.length - 2]
+        #   else
+        #     modules.first
+        #   end
+        # end
+      end
+    end
+  end
+end

data/lib/grpc_kit/grpc/stream.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'grpc_kit/grpc/dsl'
+require 'forwardable'
+
+module GrpcKit
+  module GRPC
+    class Stream
+      extend Forwardable
+      delegate %i[encode decode] => :@klass
+
+      def initialize(klass)
+        @klass = klass
+      end
+
+      # FIXME: Do not use method_missing...
+      def method_missing(name, *args, &block)
+        @klass.send(name, *args, &block)
+      end
+    end
+  end
+end

data/lib/grpc_kit/io/basic.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'ds9'
+
+module GrpcKit
+  module IO
+    class Basic
+      def initialize(reader, writer)
+        @reader = reader
+        @writer = writer
+      end
+
+      def read(length)
+        data = @reader.read_nonblock(length, nil, exception: false)
+
+        case data
+        when :wait_readable
+          DS9::ERR_WOULDBLOCK
+        when nil
+          ''
+        else
+          data
+        end
+      end
+
+      def write(data)
+        @writer.write(data)
+      end
+
+      def wait_readable
+        @reader.wait_writable
+      end
+    end
+  end
+end

data/lib/grpc_kit/rpc_desc.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'grpc_kit/grpc/stream'
+
+module GrpcKit
+  class RpcDesc
+    def initialize(name:, input:, output:, marshal_method:, unmarshal_method:)
+      @name = name
+      @input = input
+      @output = output
+      @marshal_method = marshal_method
+      @unmarshal_method = unmarshal_method
+    end
+
+    def encode(val)
+      @output.send(@marshal_method, val)
+    end
+
+    def decode(val)
+      @input.send(@unmarshal_method, val)
+    end
+
+    def encode2(val)
+      @input.send(@marshal_method, val)
+    end
+
+    def decode2(val)
+      @output.send(@unmarshal_method, val)
+    end
+
+    def invoke(rpc, val)
+      args = decode(val)
+      ret = rpc.send(to_underscore(@name), args, nil) # nil is GRPC::Call object
+      encode(ret)
+    end
+
+    def ruby_style_name
+      @ruby_style_name ||= to_underscore(@name).to_sym
+    end
+
+    def path(service_name)
+      "/#{service_name}/#{@name}".to_sym
+    end
+
+    def request_response?
+      !@input.is_a?(GrpcKit::GRPC::Stream) && !@output.is_a?(GrpcKit::GRPC::Stream)
+    end
+
+    def client_streamer?
+      @input.is_a?(GrpcKit::GRPC::Stream) && !@output.is_a?(GrpcKit::GRPC::Stream)
+    end
+
+    def server_streamer?
+      !@input.is_a?(GrpcKit::GRPC::Stream) && @output.is_a?(GrpcKit::GRPC::Stream)
+    end
+
+    def bidi_streamer?
+      @input.is_a?(GrpcKit::GRPC::Stream) && @output.is_a?(GrpcKit::GRPC::Stream)
+    end
+
+    private
+
+    def to_underscore(val)
+      val
+        .to_s
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .tr('-', '_')
+        .downcase
+    end
+  end
+end

data/lib/grpc_kit/server.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'grpc_kit/io/basic'
+require 'grpc_kit/session/server'
+
+module GrpcKit
+  class Server
+    def initialize
+      @sessions = []
+      @handler = {}
+      @rpc_descs = {}
+    end
+
+    # @params handler [object]
+    def handle(handler)
+      klass = handler.class
+
+      klass.rpc_descs.values.each do |rpc_desc|
+        path = rpc_desc.path(klass.service_name)
+        if @rpc_descs[path]
+          raise "Duplicated method registered #{key}, class: #{handler}"
+        end
+
+        @rpc_descs[path] = [rpc_desc, handler]
+      end
+    end
+
+    def run
+      GrpcKit.logger.info("Start grpc_kit v#{GrpcKit::VERSION}")
+      # XXX
+    end
+
+    def stop
+      GrpcKit.logger.info('Stop grpc_kit')
+
+      @sessions.each(&:stop)
+    end
+
+    def session_start(conn, io = GrpcKit::IO::Basic)
+      session = GrpcKit::Session::Server.new(io.new(conn, conn), self) # TODO: change self to proper object
+      @sessions << session
+
+      session.submit_settings([])
+      session.start # blocking
+    end
+
+    def on_data_chunk_recv(stream, data)
+      compressed, length, buf = data.unpack('CNa*')
+      if compressed == 0 # TODO: not
+        if length != buf.size
+          raise 'recived data inconsistent'
+        end
+
+        stream.recv(buf)
+      else
+        raise 'not supported'
+      end
+    end
+
+    def on_frame_data_recv(stream)
+      return unless stream.exist_data?
+
+      path = stream.headers[':path']
+      rpc = @rpc_descs[path.to_sym]
+      if rpc
+        resp = rpc[0].invoke(rpc[1], stream.data)
+        buf = [0, resp.length, resp].pack('CNa*')
+        stream.data = ''
+        stream.send(StringIO.new(buf))
+      else
+        # TODO: 404
+        raise "unkown path #{path}"
+      end
+    end
+  end
+end

data/lib/grpc_kit/session/client.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'ds9'
+require 'grpc_kit/session/stream'
+
+module GrpcKit
+  module Session
+    class Client < DS9::Client
+      # @io [GrpcKit::IO::XXX]
+      def initialize(io, handler)
+        super() # initialize DS9::Session
+
+        @io = io
+        @streams = {}
+        @handler = handler
+      end
+
+      def start(stream_id)
+        stream = GrpcKit::Session::Stream.new(stream_id: stream_id)
+        @streams[stream_id] = stream
+
+        while want_read? || want_write?
+          if stream.closed?
+            break
+          elsif !stream.exist_data?
+            receive
+
+            send
+          else
+            break
+            # GrpcKit.logger.info("unknown #{stream}")
+          end
+        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)
+      end
+
+      # for nghttp2_session_callbacks_set_recv_callback
+      # override
+      def recv_event(length)
+        @io.read(length)
+      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)
+      end
+
+      # provider for nghttp2_submit_response
+      # def on_data_source_read(stream_id, length)
+      # end
+
+      # for nghttp2_session_callbacks_set_on_frame_send_callback
+      # def on_frame_recv(frame)
+      #   GrpcKit.logger.debug("on_frame_recv #{frame}")
+      # 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
+
+      # # for nghttp2_session_callbacks_set_on_begin_headers_callback
+      # def on_begin_header(name, value, frame, flags)
+      # end
+
+      # # for nghttp2_session_callbacks_set_on_begin_frame_callback
+      # def on_begin_frame(frame_header)
+      # end
+
+      # # 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/server.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'ds9'
+require 'grpc_kit/session/stream'
+
+module GrpcKit
+  module Session
+    class Server < DS9::Server
+      # @io [GrpcKit::IO::XXX]
+      def initialize(io, handler)
+        super() # initialize DS9::Server
+
+        @io = io
+        @streams = {}
+        @stop = false
+        @handler = handler
+      end
+
+      def start
+        @io.wait_readable
+        until @stop && (want_read? || want_write?)
+          if want_write?
+            send
+          end
+
+          if want_read?
+            receive
+          end
+        end
+      end
+
+      def stop
+        @stop = true
+      end
+
+      private
+
+      # provider for nghttp2_submit_response
+      # override
+      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?
+          submit_trailer(stream_id, 'grpc-status' => '0')
+          false # nil mean 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
+      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
+          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}")
+        end
+
+        true
+      end
+
+      # for nghttp2_session_callbacks_set_on_frame_send_callback
+      def on_frame_send(frame)
+        GrpcKit.logger.debug("on_frame_send #{frame}")
+        true
+      end
+
+      # for 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
+      def on_begin_headers(header)
+        stream_id = header.stream_id
+        GrpcKit.logger.debug("on_begin_header stream_id=#{stream_id}")
+
+        if @streams[stream_id]
+          raise "#{stream_id} is already existed"
+        end
+
+        @streams[stream_id] = GrpcKit::Session::Stream.new(stream_id: stream_id)
+      end
+
+      # for 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
+      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}")
+        true
+      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}")
+        @streams.delete(stream_id)
+      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)
+      end
+
+      # nghttp2_session_callbacks_set_before_frame_send_callback
+      def before_frame_send(frame)
+        GrpcKit.logger.debug("before_frame_send frame=#{frame}")
+        true
+      end
+    end
+  end
+end