grpc_kit 0.1.0 → 0.1.1

data/lib/grpc_kit/errors.rb

@@ -7,18 +7,28 @@ module GrpcKit
     # https://github.com/grpc/grpc/blob/23b5b1a5a9c7084c5b64d4998ee15af0f77bd589/doc/statuscodes.md
     class BadStatus < StandardError
       def initialize(code, message)
-        super("#{code}:#{details}")
+        super("#{code} #{message}")
         @code = code
         @message = message
       end
+    end
+
+    class DeadlienExceeded < BadStatus
+      def initialize(msg)
+        super(
+          GrpcKit::StatusCodes::DEADLINE_EXCEEDED,
+          msg.to_s,
+          # "Deadline expires before server returns status: #{msg}"
+        )
+      end
+    end
 
-      class Unimplemented < BadStatus
-        def initialize(name)
-          super(
-            GrpcKit::StatusCodes::UNIMPLEMENTED,
-            "Method not found at server: #{name}"
-          )
-        end
+    class Unimplemented < BadStatus
+      def initialize(name)
+        super(
+          GrpcKit::StatusCodes::UNIMPLEMENTED,
+          "Method not found at server: #{name}"
+        )
       end
     end
   end

data/lib/grpc_kit/grpc/dsl.rb

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

data/lib/grpc_kit/grpc/generic_service.rb

@@ -7,8 +7,8 @@ module GrpcKit
     module GenericService
       def self.included(obj)
         obj.extend(GrpcKit::GRPC::Dsl)
-        return unless obj.service_name.nil?
 
+        # return unless obj.service_name.nil?
         # if obj.name.nil?
         #   obj.service_name = 'GenericService'
         # else

data/lib/grpc_kit/grpc/interceptor.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'grpc_kit/grpc/dsl'
+
+module GrpcKit
+  module GRPC
+    class Interceptor
+      def initialize(options = {})
+        @options = options
+      end
+    end
+
+    class ClientInterceptor < Interceptor
+      # rubocop:disable Lint/UnusedMethodArgument
+
+      def request_response(request: nil, call: nil, method: nil, metadata: nil)
+        yield
+      end
+
+      def client_streamer(requests: nil, call: nil, method: nil, metadata: nil)
+        yield
+      end
+
+      def server_streamer(request: nil, call: nil, method: nil, metadata: nil)
+        yield
+      end
+
+      def bidi_streamer(requests: nil, call: nil, method: nil, metadata: nil)
+        yield
+      end
+
+      # rubocop:enable Lint/UnusedMethodArgument
+    end
+
+    class ServerInterceptor < Interceptor
+      # rubocop:disable Lint/UnusedMethodArgument
+
+      def request_response(request: nil, call: nil, method: nil)
+        yield
+      end
+
+      def client_streamer(call: nil, method: nil)
+        yield
+      end
+
+      def server_streamer(request: nil, call: nil, method: nil)
+        yield
+      end
+
+      def bidi_streamer(requests: nil, call: nil, method: nil)
+        yield
+      end
+
+      # rubocop:enable Lint/UnusedMethodArgument
+    end
+  end
+end

data/lib/grpc_kit/grpc/logger.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module GrpcKit
+  module GRPC
+    module DefaultLogger
+      def self.logger
+        LOGGER
+      end
+
+      LOGGER = Logger.new(STDOUT)
+    end
+
+    unless methods.include?(:logger)
+      extend DefaultLogger
+    end
+  end
+end

data/lib/grpc_kit/interceptors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'grpc_kit/interceptors/request_response'
+require 'grpc_kit/interceptors/server_streamer'
+require 'grpc_kit/interceptors/client_streamer'
+# TODO: bidi
+
+module GrpcKit
+  module Interceptors
+  end
+end

data/lib/grpc_kit/interceptors/client_streamer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'grpc_kit/interceptors/streaming'
+
+module GrpcKit
+  module Interceptors
+    module Client
+      class ClientStreamer < Streaming
+        private
+
+        def invoke(interceptor, call)
+          # We don't need a `:requests` parameter but,
+          # it shuoldn't remove from paramters due to having a compatibility of grpc gem.
+          interceptor.client_streamer(requests: nil, call: call, method: call.method, metadata: nil) do |s|
+            yield(s)
+          end
+        end
+      end
+    end
+
+    module Server
+      class ClientStreamer < Streaming
+        def invoke(interceptor, call)
+          interceptor.client_streamer(call: call, method: call.method) do |s|
+            yield(s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grpc_kit/interceptors/request_response.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module GrpcKit
+  module Interceptors
+    module Client
+      class RequestResponse
+        attr_writer :interceptors
+
+        def initialize
+          # Cant' get interceptor at definition time...
+          @interceptors = nil
+        end
+
+        def intercept(request, call, metadata, &block)
+          if @interceptors && !@interceptors.empty?
+            do_intercept(@interceptors.dup, request, call, metadata, &block)
+          else
+            yield(request, call, metadata)
+          end
+        end
+
+        private
+
+        def do_intercept(interceptors, request, call, metadata)
+          if interceptors.empty?
+            return yield(request, call, metadata)
+          end
+
+          interceptor = interceptors.pop
+          interceptor.request_response(request: request, call: call, method: call.method, metadata: metadata) do
+            do_intercept(interceptors, request, call, metadata) do |r, c, m|
+              yield(r, c, m)
+            end
+          end
+        end
+      end
+    end
+
+    module Server
+      class RequestResponse
+        def initialize(interceptors)
+          @interceptors = interceptors
+        end
+
+        def intercept(request, call, &block)
+          if @interceptors && !@interceptors.empty?
+            do_intercept(@interceptors.dup, request, call, &block)
+          else
+            yield(request, call)
+          end
+        end
+
+        private
+
+        def do_intercept(interceptors, request, call)
+          if interceptors.empty?
+            return yield(request, call)
+          end
+
+          interceptor = interceptors.pop
+          interceptor.request_response(request: request, call: call, method: call.method) do
+            do_intercept(interceptors, request, call) do |req, c|
+              yield(req, c)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grpc_kit/interceptors/server_streamer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'grpc_kit/interceptors/streaming'
+
+module GrpcKit
+  module Interceptors
+    module Client
+      class ServerStreamer < Streaming
+        private
+
+        def invoke(interceptor, call)
+          # We don't need a `:request` parameter but,
+          # it shuoldn't remove from paramters due to having a compatibility of grpc gem.
+          interceptor.server_streamer(request: nil, call: call, method: call.method, metadata: nil) do |s|
+            yield(s)
+          end
+        end
+      end
+    end
+
+    module Server
+      class ServerStreamer < Streaming
+        def invoke(interceptor, call)
+          # We don't need a `:request` parameter but,
+          # it shuoldn't remove from paramters due to having a compatibility of grpc gem.
+          interceptor.server_streamer(request: nil, call: call, method: call.method) do |s|
+            yield(s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grpc_kit/interceptors/streaming.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module GrpcKit
+  module Interceptors
+    module Client
+      class Streaming
+        attr_writer :interceptors
+
+        def initialize
+          # Cant' get interceptor at definition time...
+          @interceptors = nil
+        end
+
+        def intercept(call, &block)
+          if @interceptors && !@interceptors.empty?
+            do_intercept(@interceptors.dup, call, &block)
+          else
+            yield(call)
+          end
+        end
+
+        private
+
+        def do_intercept(interceptors, call)
+          if interceptors.empty?
+            return yield(call)
+          end
+
+          interceptor = interceptors.pop
+          invoke(interceptor, call) do |inter_call|
+            do_intercept(interceptors, inter_call) do |c|
+              yield(c)
+            end
+          end
+        end
+      end
+    end
+
+    module Server
+      class Streaming
+        def initialize(interceptors)
+          @interceptors = interceptors
+        end
+
+        def intercept(call, &block)
+          if @interceptors && !@interceptors.empty?
+            do_intercept(@interceptors.dup, call, &block)
+          else
+            yield(call)
+          end
+        end
+
+        private
+
+        def do_intercept(interceptors, call)
+          if interceptors.empty?
+            return yield(call)
+          end
+
+          interceptor = interceptors.pop
+          invoke(interceptor, call) do |inter_call|
+            do_intercept(interceptors, inter_call) do |c|
+              yield(c)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grpc_kit/method_config.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module GrpcKit
+  MethodConfig = Struct.new(
+    :path,
+    :ruby_style_method_name,
+    :protobuf,
+    :interceptor,
+    :service_name,
+    :method_name,
+    :max_receive_message_size,
+    :max_send_message_size,
+    :compressor_type,
+  ) do
+    MAX_SERVER_RECEIVE_MESSAGE_SIZE = 1024 * 1024 * 4
+    MAX_SERVER_SEND_MESSAGE_SIZE = 1024 * 1024 * 4
+    MAX_CLIENT_RECEIVE_MESSAGE_SIZE = 1024 * 1024 * 4
+    MAX_CLIENT_SEND_MESSAGE_SIZE = 1024 * 1024 * 4
+
+    def self.build_for_server(
+          path:, ruby_style_method_name:, protobuf:, service_name:, method_name:, interceptor:,
+          max_receive_message_size: MAX_SERVER_RECEIVE_MESSAGE_SIZE, max_send_message_size: MAX_SERVER_SEND_MESSAGE_SIZE, compressor_type: ''
+        )
+      new(path, ruby_style_method_name, protobuf, interceptor, service_name, method_name, max_receive_message_size, max_send_message_size, compressor_type)
+    end
+
+    def self.build_for_client(
+          path:, ruby_style_method_name:, protobuf:, service_name:, method_name:, interceptor:,
+          max_receive_message_size: MAX_CLIENT_RECEIVE_MESSAGE_SIZE, max_send_message_size: MAX_CLIENT_SEND_MESSAGE_SIZE, compressor_type: ''
+        )
+      new(path, ruby_style_method_name, protobuf, interceptor, service_name, method_name, max_receive_message_size, max_send_message_size, compressor_type)
+    end
+  end
+end