grpc_kit 0.1.0 → 0.1.1

data/lib/grpc_kit/protobuffer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module GrpcKit
+  class ProtoBuffer
+    def initialize(encoder:, decoder:, encode_method:, decode_method:)
+      @encoder = encoder
+      @decoder = decoder
+      @encode_method = encode_method
+      @decode_method = decode_method
+    end
+
+    def encode(data)
+      @encoder.send(@encode_method, data)
+    end
+
+    def decode(data)
+      @decoder.send(@decode_method, data)
+    end
+  end
+end

data/lib/grpc_kit/rpc_desc.rb

@@ -1,65 +1,141 @@
 # frozen_string_literal: true
 
-require 'grpc_kit/grpc/stream'
+require 'grpc_kit/method_config'
+require 'grpc_kit/rpcs'
+require 'grpc_kit/protobuffer'
+require 'grpc_kit/interceptors'
 
 module GrpcKit
   class RpcDesc
-    def initialize(name:, input:, output:, marshal_method:, unmarshal_method:)
+    def initialize(name:, marshal:, unmarshal:, marshal_method:, unmarshal_method:, service_name:)
       @name = name
-      @input = input
-      @output = output
+      @marshal = marshal
+      @unmarshal = unmarshal
       @marshal_method = marshal_method
       @unmarshal_method = unmarshal_method
+      @service_name = service_name
     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 build_server(handler, interceptors: [])
+      inter = interceptors.empty? ? nil : server_interceptor.new(interceptors)
 
-    def decode2(val)
-      @output.send(@unmarshal_method, val)
+      config = GrpcKit::MethodConfig.build_for_server(
+        path: path,
+        ruby_style_method_name: ruby_style_name,
+        protobuf: server_protobuf,
+        service_name: @server_name,
+        method_name: @name,
+        interceptor: inter,
+      )
+      server.new(handler, config)
     end
 
-    def invoke(rpc, val)
-      args = decode(val)
-      ret = rpc.send(to_underscore(@name), args, nil) # nil is GRPC::Call object
-      encode(ret)
+    def build_client
+      config = GrpcKit::MethodConfig.build_for_client(
+        path: path,
+        ruby_style_method_name: ruby_style_name,
+        protobuf: client_protobuf,
+        service_name: @server_name,
+        method_name: @name,
+        interceptor: client_interceptor.new,
+      )
+      client.new(config)
     end
 
     def ruby_style_name
       @ruby_style_name ||= to_underscore(@name).to_sym
     end
 
-    def path(service_name)
-      "/#{service_name}/#{@name}".to_sym
+    def path
+      @path ||= "/#{@service_name}/#{@name}"
     end
 
     def request_response?
-      !@input.is_a?(GrpcKit::GRPC::Stream) && !@output.is_a?(GrpcKit::GRPC::Stream)
+      !@marshal.is_a?(GrpcKit::GRPC::Stream) && !@unmarshal.is_a?(GrpcKit::GRPC::Stream)
     end
 
     def client_streamer?
-      @input.is_a?(GrpcKit::GRPC::Stream) && !@output.is_a?(GrpcKit::GRPC::Stream)
+      @marshal.is_a?(GrpcKit::GRPC::Stream) && !@unmarshal.is_a?(GrpcKit::GRPC::Stream)
     end
 
     def server_streamer?
-      !@input.is_a?(GrpcKit::GRPC::Stream) && @output.is_a?(GrpcKit::GRPC::Stream)
+      !@marshal.is_a?(GrpcKit::GRPC::Stream) && @unmarshal.is_a?(GrpcKit::GRPC::Stream)
     end
 
     def bidi_streamer?
-      @input.is_a?(GrpcKit::GRPC::Stream) && @output.is_a?(GrpcKit::GRPC::Stream)
+      @marshal.is_a?(GrpcKit::GRPC::Stream) && @unmarshal.is_a?(GrpcKit::GRPC::Stream)
     end
 
     private
 
+    def server
+      @server ||=
+        if request_response?
+          GrpcKit::Rpcs::Server::RequestResponse
+        elsif client_streamer?
+          GrpcKit::Rpcs::Server::ClientStreamer
+        elsif server_streamer?
+          GrpcKit::Rpcs::Server::ServerStreamer
+        elsif bidi_streamer?
+          GrpcKit::Rpcs::Server::BidiStreamer
+        end
+    end
+
+    def client
+      @client ||=
+        if request_response?
+          GrpcKit::Rpcs::Client::RequestResponse
+        elsif client_streamer?
+          GrpcKit::Rpcs::Client::ClientStreamer
+        elsif server_streamer?
+          GrpcKit::Rpcs::Client::ServerStreamer
+        elsif bidi_streamer?
+          GrpcKit::Rpcs::Client::BidiStreamer
+        end
+    end
+
+    def server_protobuf
+      @server_protobuf ||= ProtoBuffer.new(
+        encoder: @unmarshal,
+        decoder: @marshal,
+        encode_method: @marshal_method,
+        decode_method: @unmarshal_method,
+      )
+    end
+
+    def client_protobuf
+      @client_protobuf ||= ProtoBuffer.new(
+        encoder: @marshal,
+        decoder: @unmarshal,
+        encode_method: @marshal_method,
+        decode_method: @unmarshal_method,
+      )
+    end
+
+    def server_interceptor
+      if request_response?
+        GrpcKit::Interceptors::Server::RequestResponse
+      elsif client_streamer?
+        GrpcKit::Interceptors::Server::ClientStreamer
+      elsif server_streamer?
+        GrpcKit::Interceptors::Server::ServerStreamer
+      elsif bidi_streamer?
+        GrpcKit::Interceptors::Server::RequestResponse # TODO
+      end
+    end
+
+    def client_interceptor
+      if request_response?
+        GrpcKit::Interceptors::Client::RequestResponse
+      elsif client_streamer?
+        GrpcKit::Interceptors::Client::ClientStreamer
+      elsif server_streamer?
+        GrpcKit::Interceptors::Client::ServerStreamer
+      elsif bidi_streamer?
+        GrpcKit::Interceptors::Client::RequestResponse # TODO
+      end
+    end
+
     def to_underscore(val)
       val
         .to_s

data/lib/grpc_kit/rpcs.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'grpc_kit/rpcs/request_response'
+require 'grpc_kit/rpcs/client_streamer'
+require 'grpc_kit/rpcs/server_streamer'
+require 'grpc_kit/rpcs/bidi_streamer'
+
+module GrpcKit
+  module Rpcs
+  end
+end

data/lib/grpc_kit/rpcs/base.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'timeout'
+
+require 'grpc_kit/errors'
+require 'grpc_kit/rpcs/call'
+require 'grpc_kit/streams/server'
+require 'grpc_kit/streams/client'
+
+module GrpcKit
+  module Rpcs
+    module Client
+      class Base
+        attr_reader :config
+        def initialize(config)
+          @config = config
+        end
+      end
+    end
+
+    module Server
+      class Base
+        def initialize(handler, config)
+          @handler = handler
+          @config = config
+        end
+      end
+    end
+  end
+end

data/lib/grpc_kit/rpcs/bidi_streamer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'grpc_kit/rpcs/base'
+
+module GrpcKit
+  module Rpcs
+    module Client
+      class BidiStreamer < Base
+        def invoke(session, data, opts = {}); end
+      end
+    end
+
+    module Server
+      class BidiStreamer < Base
+      end
+    end
+  end
+end

data/lib/grpc_kit/rpcs/call.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module GrpcKit
+  module Rpcs
+    # compatible for grpc gem
+    class Call
+      extend Forwardable
+
+      delegate %i[recv send_msg close_and_recv each].freeze => :@stream
+
+      Name = Struct.new(:name, :receiver)
+      Reciver = Struct.new(:class)
+      Klass = Struct.new(:service_name)
+
+      attr_reader :metadata, :method
+
+      def initialize(metadata, method_name, service_name, stream)
+        @metadata = metadata
+        klass = Klass.new(service_name)
+        @method = Name.new(method_name, Reciver.new(klass))
+        @stream = stream
+      end
+    end
+  end
+end

data/lib/grpc_kit/rpcs/client_streamer.rb

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

data/lib/grpc_kit/rpcs/request_response.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'grpc_kit/rpcs/base'
+
+module GrpcKit
+  module Rpcs
+    module Client
+      class RequestResponse < Base
+        def invoke(session, request, authority:, metadata: {}, timeout: nil, **opts)
+          cs = GrpcKit::Streams::Client.new(path: @config.path, protobuf: @config.protobuf, 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::DeadlienExceeded) 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, protobuf: @config.protobuf, session: session)
+          call = GrpcKit::Rpcs::Call.new(stream.headers.metadata, @config.method_name, @config.service_name, ss)
+
+          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

@@ -0,0 +1,42 @@
+# 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(path: @config.path, protobuf: @config.protobuf, session: session, authority: authority)
+          call = GrpcKit::Rpcs::Call.new(metadata, @config.method_name, @config.service_name, cs)
+
+          @config.interceptor.intercept(call) do |c|
+            c.send_msg(request, last: true)
+            c
+          end
+        end
+      end
+    end
+
+    module Server
+      class ServerStreamer < Base
+        def invoke(stream, session)
+          ss = GrpcKit::Streams::Server.new(stream: stream, protobuf: @config.protobuf, session: session)
+          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
+
+          stream.end_write
+        end
+      end
+    end
+  end
+end

data/lib/grpc_kit/server.rb

@@ -1,76 +1,57 @@
 # frozen_string_literal: true
 
-require 'grpc_kit/io/basic'
+require 'grpc_kit/session/io'
 require 'grpc_kit/session/server'
 
 module GrpcKit
   class Server
-    def initialize
+    def initialize(interceptors: [])
       @sessions = []
-      @handler = {}
       @rpc_descs = {}
+      @interceptors = interceptors
     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)
+      handler.class.rpc_descs.each do |path, rpc_desc|
         if @rpc_descs[path]
-          raise "Duplicated method registered #{key}, class: #{handler}"
+          raise "Duplicated method registered #{path}, class: #{handler}"
         end
 
-        @rpc_descs[path] = [rpc_desc, handler]
+        @rpc_descs[path] = rpc_desc.build_server(handler, interceptors: @interceptors)
       end
     end
 
     def run
       GrpcKit.logger.info("Start grpc_kit v#{GrpcKit::VERSION}")
-      # XXX
+
+      @rpc_descs.freeze
     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
+    def session_start(conn)
+      session = GrpcKit::Session::Server.new(
+        GrpcKit::Session::IO.new(conn),
+        self,
+      )
       @sessions << session
 
       session.submit_settings([])
       session.start # blocking
+      session.finish
     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'
+    def dispatch(stream, session)
+      rpc = @rpc_descs[stream.headers.path]
+      unless rpc
+        raise "Unkown path #{path}"
       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
+      rpc.invoke(stream, session)
     end
   end
 end