protobuffy 3.1.0

data/lib/protobuf/rpc/error.rb

@@ -0,0 +1,28 @@
+require 'protobuf/rpc/rpc.pb'
+
+module Protobuf
+  module Rpc
+    ClientError = Struct.new("ClientError", :code, :message)
+
+    # Base PbError class for client and server errors
+    class PbError < StandardError
+      attr_reader :error_type
+
+      def initialize(message='An unknown RpcError occurred', error_type='RPC_ERROR')
+        @error_type = error_type.is_a?(String) ? Socketrpc::ErrorReason.const_get(error_type) : error_type
+        super message
+      end
+
+      def encode
+        to_response.encode
+      end
+
+      def to_response
+        Socketrpc::Response.new(:error => message, :error_reason => error_type)
+      end
+    end
+  end
+end
+
+require 'protobuf/rpc/error/server_error'
+require 'protobuf/rpc/error/client_error'

data/lib/protobuf/rpc/error/client_error.rb

@@ -0,0 +1,31 @@
+require 'protobuf/rpc/error'
+
+module Protobuf
+  module Rpc
+
+    class InvalidRequestProto < PbError
+      def initialize(message='Invalid request type given')
+        super message, 'INVALID_REQUEST_PROTO'
+      end
+    end
+
+    class BadResponseProto < PbError
+      def initialize(message='Bad response type from server')
+        super message, 'BAD_RESPONSE_PROTO'
+      end
+    end
+
+    class UnkownHost < PbError
+      def initialize(message='Unknown host or port')
+        super message, 'UNKNOWN_HOST'
+      end
+    end
+
+    class IOError < PbError
+      def initialize(message='IO Error occurred')
+        super message, 'IO_ERROR'
+      end
+    end
+
+  end
+end

data/lib/protobuf/rpc/error/server_error.rb

@@ -0,0 +1,43 @@
+require 'protobuf/rpc/rpc.pb'
+
+module Protobuf
+  module Rpc
+
+    class BadRequestData < PbError
+      def initialize message='Unable to parse request'
+        super message, 'BAD_REQUEST_DATA'
+      end
+    end
+
+    class BadRequestProto < PbError
+      def initialize message='Request is of wrong type'
+        super message, 'BAD_REQUEST_PROTO'
+      end
+    end
+
+    class ServiceNotFound < PbError
+      def initialize message='Service class not found'
+        super message, 'SERVICE_NOT_FOUND'
+      end
+    end
+
+    class MethodNotFound < PbError
+      def initialize message='Service method not found'
+        super message, 'METHOD_NOT_FOUND'
+      end
+    end
+
+    class RpcError < PbError
+      def initialize message='RPC exception occurred'
+        super message, 'RPC_ERROR'
+      end
+    end
+
+    class RpcFailed < PbError
+      def initialize message='RPC failed'
+        super message, 'RPC_FAILED'
+      end
+    end
+
+  end
+end

data/lib/protobuf/rpc/middleware.rb

@@ -0,0 +1,25 @@
+require 'middleware'
+
+require 'protobuf/rpc/middleware/exception_handler'
+require 'protobuf/rpc/middleware/logger'
+require 'protobuf/rpc/middleware/request_decoder'
+require 'protobuf/rpc/middleware/response_encoder'
+require 'protobuf/rpc/middleware/runner'
+
+module Protobuf
+  module Rpc
+    def self.middleware
+      @middleware ||= ::Middleware::Builder.new(:runner_class => ::Protobuf::Rpc::Middleware::Runner)
+    end
+
+    # Ensure the middleware stack is initialized
+    middleware
+  end
+
+  Rpc.middleware.use(Rpc::Middleware::ExceptionHandler)
+  Rpc.middleware.use(Rpc::Middleware::RequestDecoder)
+  Rpc.middleware.use(Rpc::Middleware::Logger)
+  Rpc.middleware.use(Rpc::Middleware::ResponseEncoder)
+
+  ActiveSupport.run_load_hooks(:protobuf_rpc_middleware, Rpc)
+end

data/lib/protobuf/rpc/middleware/exception_handler.rb

@@ -0,0 +1,36 @@
+module Protobuf
+  module Rpc
+    module Middleware
+      class ExceptionHandler
+        include ::Protobuf::Logger::LogMethods
+
+        attr_reader :app
+
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          app.call(env)
+        rescue => exception
+          log_exception(exception)
+
+          # Rescue exceptions, re-wrap them as generic Protobuf errors,
+          # and encode them
+          env.response = wrap_exception(exception)
+          env.encoded_response = env.response.encode
+          env
+        end
+
+      private
+
+        # Wrap exceptions in a generic Protobuf errors unless they already are
+        #
+        def wrap_exception(exception)
+          exception = RpcFailed.new(exception.message) unless exception.is_a?(PbError)
+          exception
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/middleware/logger.rb

@@ -0,0 +1,91 @@
+module Protobuf
+  module Rpc
+    module Middleware
+      class Logger
+        def initialize(app)
+          @app = app
+        end
+
+        # TODO: Figure out how to control when logs are flushed
+        def call(env)
+          instrumenter.start
+          instrumenter.flush(env) # Log request stats
+
+          env = @app.call(env)
+
+          instrumenter.stop
+          instrumenter.flush(env) # Log response stats
+
+          env
+        end
+
+      private
+
+        def instrumenter
+          @instrumenter ||= Instrumenter.new
+        end
+
+        # TODO: Replace this with ActiveSupport::Notifications and log subscribers
+        # TODO: Consider adopting Rails-style logging so we can track serialization
+        # time as well as ActiveRecord time, etc.:
+        #
+        #     Started GET "/" for 127.0.0.1 at 2014-02-12 09:40:29 -0700
+        #     Processing by ReleasesController#index as HTML
+        #       Rendered releases/_release.html.erb (0.0ms)
+        #       Rendered releases/_release.html.erb (0.0ms)
+        #       Rendered releases/_release.html.erb (0.0ms)
+        #       Rendered releases/_release.html.erb (0.0ms)
+        #       Rendered releases/index.html.erb within layouts/application (11.0ms)
+        #     Completed 200 OK in 142ms (Views: 117.6ms | ActiveRecord: 1.7ms)
+        #
+        class Instrumenter
+          attr_reader :env
+
+          def flush(env)
+            Protobuf::Logger.info { to_s(env) }
+          end
+
+          def start
+            @start_time = ::Time.now.utc
+          end
+
+          def stop
+            @end_time = ::Time.now.utc
+          end
+
+          def to_s(env)
+            @env = env
+
+            [
+              "[SRV]",
+              env.client_host,
+              env.worker_id,
+              rpc,
+              sizes,
+              elapsed_time,
+              @end_time.try(:iso8601)
+            ].compact.join(' - ')
+          end
+
+        private
+
+          def elapsed_time
+            (@start_time && @end_time ? "#{(@end_time - @start_time).round(4)}s" : nil)
+          end
+
+          def rpc
+            env.service_name && env.method_name ? "#{env.service_name}##{env.method_name}" : nil
+          end
+
+          def sizes
+            if env.encoded_response?
+              "#{env.encoded_request.size}B/#{env.encoded_response.size}B"
+            else
+              "#{env.encoded_request.size}B/-"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/middleware/request_decoder.rb

@@ -0,0 +1,83 @@
+module Protobuf
+  module Rpc
+    module Middleware
+      class RequestDecoder
+        include ::Protobuf::Logger::LogMethods
+
+        attr_reader :app, :env
+
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          @env = env
+
+          env.service_name = service_name
+          env.method_name = method_name
+          env.request = request
+          env.client_host = request_wrapper.caller
+
+          env.rpc_service = service
+          env.rpc_method = rpc_method
+          env.request_type = rpc_method.request_type
+          env.response_type = rpc_method.response_type
+
+          app.call(env)
+        end
+
+        def log_signature
+          env.signature || super
+        end
+
+      private
+
+        def method_name
+          @method_name ||= begin
+            method_name = request_wrapper.method_name.underscore.to_sym
+
+            unless service.rpc_method?(method_name)
+              raise MethodNotFound.new("#{service.name}##{method_name} is not a defined RPC method.")
+            end
+
+            method_name
+          end
+        end
+
+        def request
+          @request ||= begin
+            data = request_wrapper.request_proto
+            rpc_method.request_type.decode(data)
+          end
+        rescue => exception
+          raise BadRequestData.new("Unable to decode request: #{exception.message}")
+        end
+
+        # Decode the incoming request object into our expected request object
+        #
+        def request_wrapper
+          @request_wrapper ||= begin
+            log_debug { sign_message("Decoding request: #{env.encoded_request}") }
+            Socketrpc::Request.decode(env.encoded_request)
+          end
+        rescue => exception
+          raise BadRequestData.new("Unable to decode request: #{exception.message}")
+        end
+
+        def rpc_method
+          @rpc_method ||= service.rpcs[method_name]
+        end
+
+        def service
+          @service ||= service_name.constantize
+        rescue NameError
+          raise ServiceNotFound.new("Service class #{service_name} is not defined.")
+        end
+
+        def service_name
+          @service_name ||= request_wrapper.service_name
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/middleware/response_encoder.rb

@@ -0,0 +1,88 @@
+module Protobuf
+  module Rpc
+    module Middleware
+      class ResponseEncoder
+        include ::Protobuf::Logger::LogMethods
+
+        attr_reader :app, :env
+
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          @env = app.call(env)
+
+          env.response = response
+          env.encoded_response = encoded_response
+          env
+        end
+
+        def log_signature
+          env.signature || super
+        end
+
+      private
+
+        # Encode the response wrapper to return to the client
+        #
+        def encoded_response
+          log_debug { sign_message("Encoding response: #{response.inspect}") }
+
+          env.encoded_response = wrapped_response.encode
+        rescue => exception
+          log_exception(exception)
+
+          # Rescue encoding exceptions, re-wrap them as generic protobuf errors,
+          # and re-raise them
+          raise PbError.new(exception.message)
+        end
+
+        # Prod the object to see if we can produce a proto object as a response
+        # candidate. Validate the candidate protos.
+        def response
+          @response ||= begin
+                          candidate = env.response
+                          case
+                          when candidate.is_a?(Message) then
+                            validate!(candidate)
+                          when candidate.respond_to?(:to_proto) then
+                            validate!(candidate.to_proto)
+                          when candidate.respond_to?(:to_hash) then
+                            env.response_type.new(candidate.to_hash)
+                          when candidate.is_a?(PbError) then
+                            candidate
+                          else
+                            validate!(candidate)
+                          end
+                        end
+        end
+
+        # Ensure that the response candidate we've been given is of the type
+        # we expect so that deserialization on the client side works.
+        #
+        def validate!(candidate)
+          actual = candidate.class
+          expected = env.response_type
+
+          if expected != actual
+            raise BadResponseProto.new("Expected response to be of type #{expected.name} but was #{actual.name}")
+          end
+
+          candidate
+        end
+
+        # The middleware stack returns either an error or response proto. Package
+        # it up so that it's in the correct spot in the response wrapper
+        #
+        def wrapped_response
+          if response.is_a?(Protobuf::Rpc::PbError)
+            Socketrpc::Response.new(:error => response.message, :error_reason => response.error_type)
+          else
+            Socketrpc::Response.new(:response_proto => response.encode)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/middleware/runner.rb

@@ -0,0 +1,18 @@
+require 'middleware/runner'
+
+module Protobuf
+  module Rpc
+    module Middleware
+      class Runner < ::Middleware::Runner
+        # Override the default middleware runner so we can ensure that the
+        # service dispatcher is the last thing called in the stack.
+        #
+        def initialize(stack)
+          stack << Protobuf::Rpc::ServiceDispatcher
+
+          super(stack)
+        end
+      end
+    end
+  end
+end