protobuf 2.8.13 → 3.0.0.rc1

data/lib/protobuf/rpc/client.rb

@@ -134,7 +134,7 @@ module Protobuf
         end
       end
 
-      # Send the request to the service through eventmachine.
+      # Send the request to the service.
       # This method is usually never called directly
       # but is invoked by method_missing (see docs above).
       #
@@ -163,8 +163,6 @@ module Protobuf
 
     end
 
-    if ActiveSupport::VERSION::MAJOR > 2
-      ActiveSupport.run_load_hooks(:protobuf_rpc_client, Client)
-    end
+    ActiveSupport.run_load_hooks(:protobuf_rpc_client, Client)
   end
 end

data/lib/protobuf/rpc/connector.rb

@@ -7,8 +7,6 @@ module Protobuf
       # Returns a connector class for the pre-defined connector_type.
       def self.connector_for_client
         case ::Protobuf.connector_type
-        when :evented then
-          ::Protobuf::Rpc::Connectors::EventMachine
         when :zmq then
           ::Protobuf::Rpc::Connectors::Zmq
         else

data/lib/protobuf/rpc/connectors/common.rb

@@ -40,7 +40,7 @@ module Protobuf
         # @param [String] message The error message
         def fail(code, message)
           @error =  ClientError.new
-          @error.code = code.is_a?(Symbol) ? Protobuf::Socketrpc::ErrorReason.values[code] : code
+          @error.code = Protobuf::Socketrpc::ErrorReason.fetch(code)
           @error.message = message
           log_debug { sign_message("Server failed request (invoking on_failure): #{@error.inspect}") }
 
@@ -74,7 +74,7 @@ module Protobuf
           log_debug { sign_message("Parsing response from server (connection closed)") }
 
           # Parse out the raw response
-          @stats.response_size = @response_data.size
+          @stats.response_size = @response_data.size unless @response_data.nil?
           response_wrapper = Protobuf::Socketrpc::Response.decode(@response_data)
 
           # Determine success or failure based on parsed data

data/lib/protobuf/rpc/dynamic_discovery.pb.rb

@@ -4,11 +4,9 @@
 require 'protobuf/message'
 
 module Protobuf
-
   module Rpc
-  
     module DynamicDiscovery
-    
+
       ##
       # Enum Classes
       #
@@ -16,34 +14,34 @@ module Protobuf
         define :HEARTBEAT, 0
         define :FLATLINE, 1
       end
-      
-      
+
+
       ##
       # Message Classes
       #
       class Server < ::Protobuf::Message; end
       class Beacon < ::Protobuf::Message; end
-      
+
+
       ##
       # Message Fields
       #
       class Server
-        optional ::Protobuf::Field::StringField, :uuid, 1
-        optional ::Protobuf::Field::StringField, :address, 2
-        optional ::Protobuf::Field::StringField, :port, 3
-        optional ::Protobuf::Field::Int32Field, :ttl, 4
-        repeated ::Protobuf::Field::StringField, :services, 5
+        optional :string, :uuid, 1
+        optional :string, :address, 2
+        optional :string, :port, 3
+        optional :int32, :ttl, 4
+        repeated :string, :services, 5
       end
-      
+
       class Beacon
         optional ::Protobuf::Rpc::DynamicDiscovery::BeaconType, :beacon_type, 1
         optional ::Protobuf::Rpc::DynamicDiscovery::Server, :server, 2
       end
-      
-      
+
     end
-    
+
   end
-  
+
 end
 

data/lib/protobuf/rpc/env.rb

@@ -0,0 +1,58 @@
+module Protobuf
+  module Rpc
+    class Env < Hash
+      # Creates an accessor that simply sets and reads a key in the hash:
+      #
+      #   class Config < Hash
+      #     hash_accessor :app
+      #   end
+      #
+      #   config = Config.new
+      #   config.app = Foo
+      #   config[:app] #=> Foo
+      #
+      #   config[:app] = Bar
+      #   config.app #=> Bar
+      #
+      def self.hash_accessor(*names) #:nodoc:
+        names.each do |name|
+          class_eval <<-METHOD, __FILE__, __LINE__ + 1
+            def #{name}
+              self['#{name}']
+            end
+
+            def #{name}=(value)
+              self['#{name}'] = value
+            end
+
+            def #{name}?
+              ! self['#{name}'].nil?
+            end
+          METHOD
+        end
+      end
+
+      # TODO: Add extra info about the environment (i.e. variables) and other
+      # information that might be useful
+      hash_accessor :client_host,
+                    :encoded_request,
+                    :encoded_response,
+                    :log_signature,
+                    :method_name,
+                    :request,
+                    :request_type,
+                    :response,
+                    :response_type,
+                    :rpc_method,
+                    :rpc_service,
+                    :service_name,
+                    :worker_id
+
+      def initialize(options={})
+        merge!(options)
+
+        self['worker_id'] = ::Thread.current.object_id.to_s(16)
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/error.rb

@@ -8,14 +8,17 @@ module Protobuf
     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) ? ::Protobuf::Socketrpc::ErrorReason.const_get(error_type) : 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 to_response response
-        response.error = message
-        response.error_reason = @error_type
+      def encode
+        to_response.encode
+      end
+
+      def to_response
+        Socketrpc::Response.new(:error => message, :error_reason => error_type)
       end
     end
   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

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/rpc.pb.rb

@@ -4,9 +4,8 @@
 require 'protobuf/message'
 
 module Protobuf
-
   module Socketrpc
-  
+
     ##
     # Enum Classes
     #
@@ -22,33 +21,33 @@ module Protobuf
       define :UNKNOWN_HOST, 8
       define :IO_ERROR, 9
     end
-    
-    
+
+
     ##
     # Message Classes
     #
     class Request < ::Protobuf::Message; end
     class Response < ::Protobuf::Message; end
-    
+
+
     ##
     # Message Fields
     #
     class Request
-      required ::Protobuf::Field::StringField, :service_name, 1
-      required ::Protobuf::Field::StringField, :method_name, 2
-      optional ::Protobuf::Field::BytesField, :request_proto, 3
-      optional ::Protobuf::Field::StringField, :caller, 4
+      required :string, :service_name, 1
+      required :string, :method_name, 2
+      optional :bytes, :request_proto, 3
+      optional :string, :caller, 4
     end
-    
+
     class Response
-      optional ::Protobuf::Field::BytesField, :response_proto, 1
-      optional ::Protobuf::Field::StringField, :error, 2
-      optional ::Protobuf::Field::BoolField, :callback, 3, :default => false
+      optional :bytes, :response_proto, 1
+      optional :string, :error, 2
+      optional :bool, :callback, 3, :default => false
       optional ::Protobuf::Socketrpc::ErrorReason, :error_reason, 4
     end
-    
-    
+
   end
-  
+
 end