protobuf 2.8.13 → 3.0.0.rc1

data/lib/protobuf/rpc/server.rb

@@ -2,88 +2,38 @@ require 'protobuf'
 require 'protobuf/logger'
 require 'protobuf/rpc/rpc.pb'
 require 'protobuf/rpc/buffer'
+require 'protobuf/rpc/env'
 require 'protobuf/rpc/error'
-require 'protobuf/rpc/stat'
+require 'protobuf/rpc/middleware'
 require 'protobuf/rpc/service_dispatcher'
 
 module Protobuf
   module Rpc
     module Server
-
-      def initialize_request!
-        log_debug { sign_message('Post init') }
-        @request = ::Protobuf::Socketrpc::Request.new
-        @response = ::Protobuf::Socketrpc::Response.new
-        @stats = Protobuf::Rpc::Stat.new(:SERVER)
-      end
-
-      def disable_gc!
+      def gc_pause
         ::GC.disable if ::Protobuf.gc_pause_server_request?
-      end
 
-      def enable_gc!
-        ::GC.enable && ::GC.start if ::Protobuf.gc_pause_server_request?
+        yield
+
+        ::GC.enable if ::Protobuf.gc_pause_server_request?
       end
 
       # Invoke the service method dictated by the proto wrapper request object
-      def handle_client
-        parse_request_from_buffer
-        @stats.client = @request.caller
+      #
+      def handle_request(request_data)
+        # Create an env object that holds different parts of the environment and
+        # is available to all of the middlewares
+        env = Env.new('encoded_request' => request_data, 'log_signature' => log_signature)
 
-        @dispatcher = ::Protobuf::Rpc::ServiceDispatcher.new(@request)
-        @stats.dispatcher = @dispatcher
-        log_info { @stats.to_s }
+        # Invoke the middleware stack, the last of which is the service dispatcher
+        env = Rpc.middleware.call(env)
 
-        disable_gc!
-        @dispatcher.invoke!
-        if @dispatcher.success?
-          @response.response_proto = @dispatcher.response
-        else
-          handle_error(@dispatcher.error)
-        end
-      rescue => error
-        log_exception(error)
-        handle_error(error)
-      ensure
-        send_response
-      end
-
-      # Client error handler. Receives an exception object and writes it into the @response
-      def handle_error(error)
-        log_debug { sign_message("handle_error: #{error.inspect}") }
-        if error.respond_to?(:to_response)
-          error.to_response(@response)
-        else
-          message = error.respond_to?(:message) ? error.message : error.to_s
-          code = error.respond_to?(:code) ? error.code : 'RPC_ERROR'
-          ::Protobuf::Rpc::PbError.new(message, code).to_response(@response)
-        end
+        env.encoded_response
       end
 
       def log_signature
         @_log_signature ||= "[server-#{self.class.name}]"
       end
-
-      # Parse the incoming request object into our expected request object
-      def parse_request_from_buffer
-        log_debug { sign_message("Parsing request from buffer: #{@request_data}") }
-        @stats.request_size = @request_data.size
-        @request.decode(@request_data)
-      rescue => error
-        exc = ::Protobuf::Rpc::BadRequestData.new("Unable to parse request: #{error.message}")
-        log_error { exc.message }
-        raise exc
-      end
-
-      # Write the response wrapper to the client
-      def send_response
-        log_debug { sign_message("Sending response to client: #{@response.inspect}") }
-        send_data
-      ensure
-        @stats.stop
-        log_info { @stats.to_s }
-        enable_gc!
-      end
     end
   end
 end

data/lib/protobuf/rpc/servers/socket/server.rb

@@ -4,9 +4,7 @@ require 'protobuf/rpc/servers/socket/worker'
 module Protobuf
   module Rpc
     module Socket
-
       class Server
-        include ::Protobuf::Rpc::Server
         include ::Protobuf::Logger::LogMethods
 
         AUTO_COLLECT_TIMEOUT = 5 # seconds

data/lib/protobuf/rpc/servers/socket/worker.rb

@@ -4,24 +4,21 @@ require 'protobuf/logger'
 module Protobuf
   module Rpc
     module Socket
-
       class Worker
         include ::Protobuf::Rpc::Server
         include ::Protobuf::Logger::LogMethods
 
         def initialize(sock, &complete_cb)
           @socket = sock
-          initialize_request!
-
-          request_buffer = Protobuf::Rpc::Buffer.new(:read)
           @complete_cb = complete_cb
 
-          log_debug { sign_message("stats are #{@stats.to_s}") }
-          request_buffer << read_data
-          @request_data = request_buffer.data
+          data = read_data
+          return unless data
 
-          log_debug { sign_message("handling request") }
-          handle_client if request_buffer.flushed?
+          gc_pause do
+            encoded_response = handle_request(data)
+            send_data(encoded_response)
+          end
         end
 
         def read_data
@@ -32,17 +29,17 @@ module Protobuf
           end
           str_size_io = size_io.string
 
-          "#{str_size_io}-#{@socket.read(str_size_io.to_i)}"
+          @socket.read(str_size_io.to_i)
         end
 
-        def send_data
+        def send_data(data)
           raise 'Socket closed unexpectedly' unless socket_writable?
           response_buffer = Protobuf::Rpc::Buffer.new(:write)
-          response_buffer.set_data(@response)
-          @stats.response_size = response_buffer.size
-          log_debug { sign_message("sending data : #{response_buffer.data}") }
+          response_buffer.set_data(data)
+
           @socket.write(response_buffer.write)
           @socket.flush
+
           @complete_cb.call(@socket)
         end
 
@@ -54,7 +51,6 @@ module Protobuf
           ! @socket.nil? && ! @socket.closed?
         end
       end
-
     end
   end
 end

data/lib/protobuf/rpc/servers/zmq/util.rb

@@ -4,6 +4,7 @@ module Protobuf
   module Rpc
     module Zmq
 
+      ADDRESS_MATCH = /\A\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\z/.freeze
       WORKER_READY_MESSAGE = "\1"
 
       module Util
@@ -33,7 +34,9 @@ module Protobuf
         end
 
         def resolve_ip(hostname)
-          ::Resolv.getaddress(hostname)
+          ::Resolv.getaddresses(hostname).detect do |address|
+            address =~ ADDRESS_MATCH
+          end
         end
       end
     end

data/lib/protobuf/rpc/servers/zmq/worker.rb

@@ -26,11 +26,12 @@ module Protobuf
         # Instance Methods
         #
         def process_request
-          @client_address, _, @request_data = read_from_backend
+          client_address, _, data = read_from_backend
+          return unless data
 
-          unless @request_data.nil?
-            log_debug { sign_message("handling request") }
-            handle_client
+          gc_pause do
+            encoded_response = handle_request(data)
+            write_to_backend([client_address, "", encoded_response])
           end
         end
 
@@ -53,7 +54,6 @@ module Protobuf
 
             if rc > 0
               ::Thread.current[:busy] = true
-              initialize_request!
               process_request
               ::Thread.current[:busy] = false
             end
@@ -66,14 +66,6 @@ module Protobuf
           @server.running?
         end
 
-        def send_data
-          data = @response.encode
-
-          @stats.response_size = data.size
-
-          write_to_backend([@client_address, "", data])
-        end
-
         private
 
         def init_zmq_context

data/lib/protobuf/rpc/servers/zmq_runner.rb

@@ -20,7 +20,7 @@ module Protobuf
       def run
         @server = ::Protobuf::Rpc::Zmq::Server.new(@options)
         register_signals
-        @server.run do 
+        @server.run do
           yield if block_given?
         end
       end

data/lib/protobuf/rpc/service.rb

@@ -5,23 +5,32 @@ require 'protobuf/rpc/service_filters'
 
 module Protobuf
   module Rpc
-
     # Object to encapsulate the request/response types for a given service method
     #
     RpcMethod = Struct.new("RpcMethod", :method, :request_type, :response_type)
 
     class Service
-      include ::Protobuf::Rpc::ServiceFilters
       include ::Protobuf::Logger::LogMethods
-
+      include ::Protobuf::Rpc::ServiceFilters
 
       DEFAULT_HOST = '127.0.0.1'.freeze
       DEFAULT_PORT = 9399
 
+      attr_reader :env, :request
+
       ##
-      # Class Methods
+      # Constructor!
       #
+      # Initialize a service with the rpc endpoint name and the bytes
+      # for the request.
+      def initialize(env)
+        @env = env.dup # Dup the env so it doesn't change out from under us
+        @request = env.request
+      end
 
+      ##
+      # Class Methods
+      #
       # Create a new client for the given service.
       # See Client#initialize and ClientConnection::DEFAULT_OPTIONS
       # for all available options.
@@ -54,6 +63,18 @@ module Protobuf
         @_host = new_host
       end
 
+      # An array of defined service classes that contain implementation
+      # code
+      def self.implemented_services
+        classes = (self.subclasses || []).select do |subclass|
+          subclass.rpcs.any? do |(name, _)|
+            subclass.method_defined? name
+          end
+        end
+
+        classes.map(&:name)
+      end
+
       # Shorthand call to configure, passing a string formatted as hostname:port
       # e.g. 127.0.0.1:9933
       # e.g. localhost:0
@@ -96,36 +117,16 @@ module Protobuf
         rpcs.key?(name)
       end
 
-      # An array of defined service classes that contain implementation
-      # code
-      def self.implemented_services
-        classes = (self.subclasses || []).select do |subclass|
-          subclass.rpcs.any? do |(name, _)|
-            subclass.method_defined? name
-          end
-        end
-
-        classes.map(&:name)
-      end
-
       ##
       # Instance Methods
       #
-
-      attr_reader :response, :method_name, :client_host
-
-      # Initialize a service with the rpc endpoint name and the bytes
-      # for the request.
-      def initialize(method_name, request_bytes, client_host = nil)
-        @method_name = method_name
-        @client_host = client_host
-        @_request_bytes = request_bytes
-      end
-
-      # Register a failure callback for use when rpc_failed is invoked.
+      # Get a callable object that will be used by the dispatcher
+      # to invoke the specified rpc method. Facilitates callback dispatch.
+      # The returned lambda is expected to be called at a later time (which
+      # is why we wrap the method call).
       #
-      def on_rpc_failed(callable)
-        @_rpc_failed_callback ||= callable
+      def callable_rpc_method(method_name)
+        lambda { run_filters(method_name) }
       end
 
       # Response object for this rpc cycle. Not assignable.
@@ -134,18 +135,6 @@ module Protobuf
         @_response ||= response_type.new
       end
 
-      # Request object for this rpc cycle. Not assignable.
-      #
-      def request
-        @_request ||= if @_request_bytes.present?
-            request_type.decode(@_request_bytes)
-          else
-            request_type.new
-          end
-      rescue => e
-        raise BadRequestProto, "Unable to parse request: #{e.message}"
-      end
-
       # Convenience method to get back to class method.
       #
       def rpc_method?(name)
@@ -158,23 +147,10 @@ module Protobuf
         self.class.rpcs
       end
 
-      # Get a callable object that will be used by the dispatcher
-      # to invoke the specified rpc method. Facilitates callback dispatch.
-      # The returned lambda is expected to be called at a later time (which
-      # is why we wrap the method call).
-      #
-      def callable_rpc_method(method_name)
-        lambda { run_filters(method_name) }
-      end
-
-      private
-
-      def response_type
-        @_response_type ||= rpcs[@method_name].response_type
-      end
+    private
 
       def request_type
-        @_request_type ||= rpcs[@method_name].request_type
+        @_request_type ||= env.request_type
       end
 
       # Sugar to make an rpc method feel like a controller method.
@@ -186,28 +162,18 @@ module Protobuf
       end
       alias_method :return_from_whence_you_came, :respond_with
 
-      # Renamed attribute from prior implementaiton due to lack of clarity
-      # in what the variable contained. DEPRECATED.
-      def rpc
-        if ::Protobuf.print_deprecation_warnings?
-          $stderr.puts <<-ERROR
-            [WARNING] Service#rpc method has been deprecated
-                      and will be removed in a future version of protobuf.
-          ERROR
-        end
-        @method_name
+      def response_type
+        @_response_type ||= env.response_type
       end
 
       # Automatically fail a service method.
       #
       def rpc_failed(message)
-        @_rpc_failed_callback.call(message)
+        message = message.message if message.respond_to?(:message)
+        raise RpcFailed.new(message)
       end
-
     end
 
-    if ActiveSupport::VERSION::MAJOR > 2
-      ActiveSupport.run_load_hooks(:protobuf_rpc_service, Service)
-    end
+    ActiveSupport.run_load_hooks(:protobuf_rpc_service, Service)
   end
 end

data/lib/protobuf/rpc/service_dispatcher.rb

@@ -3,130 +3,42 @@ require 'protobuf/logger'
 module Protobuf
   module Rpc
     class ServiceDispatcher
-
       include ::Protobuf::Logger::LogMethods
 
-      attr_accessor :service, :service_klass, :callable_method, :outer_request
-      attr_accessor :definition, :response, :error
-
-      def initialize(wrapper_request)
-        self.error = nil
-        self.outer_request = wrapper_request
-
-        init_service
-        init_method if service_klass.present?
-        register_rpc_failed if service.present?
-      end
-
-      # Call the given service method. If we get to this point and an error
-      # has already occurred, do not invoke the method and simply respond.
-      #
-      def invoke!
-        unless error?
-          callable_method.call
-          validate_response
-        end
-
-        return error || response
-      end
-
-      # We're successful if the error is not populated.
-      #
-      def success?
-        error.nil?
-      end
-
-      # We're in error if the error is populated.
-      #
-      def error?
-        ! success?
-      end
-
-      private
+      attr_reader :env
 
-      def assign_error(error_klass, message)
-        self.error = error_klass.new(message)
+      def initialize(app)
+        # End of the line...
       end
 
-      # Prod the object to see if we can produce a proto object as a response
-      # candidate. Either way, return the candidate for validation.
-      def coerced_response
-        candidate = service.response
+      def call(env)
+        @env = env
 
-        case
-        when candidate.is_a?(::Protobuf::Message) then
-          # no-op
-        when candidate.respond_to?(:to_proto) then
-          candidate = candidate.to_proto
-        when candidate.respond_to?(:to_proto_hash) then
-          candidate = definition.response_type.new(candidate.to_proto_hash)
-        when candidate.respond_to?(:to_hash) then
-          candidate = definition.response_type.new(candidate.to_hash)
-        end
-
-        candidate
+        env.response = dispatch_rpc_request
+        env
       end
 
-      # Get the method for the current request.
-      #
-      def init_method
-        method_name = outer_request.method_name.underscore.to_sym
-        request_proto = outer_request.has_field?(:request_proto) ? outer_request.request_proto : nil
-
-        if service_klass.rpc_method?(method_name)
-          self.service = service_klass.new(method_name, request_proto, outer_request.caller)
-          self.callable_method = service.callable_rpc_method(method_name)
-          self.definition = service.rpcs[method_name]
-        else
-          assign_error(MethodNotFound, "#{service.class.name}##{method_name} is not a defined rpc method.")
-        end
-      rescue NameError => e
-        # FIXME I think this is no longer applicable since the method extract
-        # is now wrapped in a lambda (@see Service#callable_rpc_method).
-        log_exception(e)
-        assign_error(MethodNotFound, "#{service.class.name}##{method_name} is not implemented.")
+      def rpc_service
+        @rpc_service ||= env.rpc_service.new(env)
       end
 
-      # Constantize the service for this request. Initialization of the service
-      # happens when we verify that the method is callable for this service.
-      #
-      def init_service
-        self.service_klass = outer_request.service_name.constantize
-      rescue NameError => e
-        log_exception(e)
-        assign_error(ServiceNotFound, "Service class #{outer_request.service_name} is not defined.")
-      end
+    private
 
-      # Make sure we get rpc errors back.
-      #
-      def register_rpc_failed
-        service.on_rpc_failed(method(:rpc_failed_callback))
+      # Call the given service method.
+      def dispatch_rpc_request
+        rpc_service.callable_rpc_method(method_name).call
+        rpc_service.response
+      rescue NoMethodError
+        raise MethodNotFound.new("#{service_name}##{method_name} is not implemented.")
       end
 
-      # Receive the failure message from the service. This method is registered
-      # as the callable to the service when an `rpc_failed` call is invoked.
-      #
-      def rpc_failed_callback(message)
-        assign_error(RpcFailed, (message.respond_to?(:message) ? message.message : message))
-        log_error { sign_message("RPC Failed: #{error.message}") }
+      def method_name
+        env.method_name
       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_response
-        candidate = coerced_response
-        expected = definition.response_type
-        actual = candidate.class
-
-        if expected == actual
-          self.response = candidate
-        else
-          assign_error(BadResponseProto, "Response proto changed from #{expected.name} to #{actual.name}")
-        end
+      def service_name
+        env.service_name
       end
-
     end
   end
 end
-

data/lib/protobuf/version.rb

@@ -1,4 +1,3 @@
 module Protobuf
-  VERSION = '2.8.13'
-  PROTOC_VERSION = '2.5.0'
+  VERSION = '3.0.0.rc1'
 end

data/lib/protobuf.rb

@@ -2,25 +2,17 @@ require 'logger'
 require 'socket'
 require 'pp'
 require 'stringio'
+
 require 'active_support/core_ext/object/blank'
-require 'active_support/version'
+require 'active_support/core_ext/object/try'
 require 'active_support/notifications'
-
-if ActiveSupport::VERSION::MAJOR > 2
-  require 'active_support/core_ext/object/try'
-else
-  require 'active_support/core_ext/module/delegation'
-  require 'active_support/core_ext/kernel/reporting'
-  require 'active_support/core_ext/try'
-end
-
 require 'active_support/inflector'
 require 'active_support/json'
 
 module Protobuf
 
   # See Protobuf#connector_type documentation.
-  CONNECTORS = [ :socket, :zmq, :evented ].freeze
+  CONNECTORS = [ :socket, :zmq ].freeze
 
   # Default is Socket as it has no external dependencies.
   DEFAULT_CONNECTOR = :socket
@@ -65,7 +57,7 @@ module Protobuf
   # This optomization provides a huge boost in speed to rpc requests.
   def self.gc_pause_server_request?
     return @_gc_pause_server_request unless @_gc_pause_server_request.nil?
-    gc_pause_server_request = false
+    self.gc_pause_server_request = false
   end
 
   def self.gc_pause_server_request=(value)
@@ -84,7 +76,7 @@ module Protobuf
   # The rpc_server option will override the ENV setting.
   def self.print_deprecation_warnings?
     return @_print_deprecation_warnings unless @_print_deprecation_warnings.nil?
-    print_deprecation_warnings = ENV.key?('PB_IGNORE_DEPRECATIONS') ? false : true
+    self.print_deprecation_warnings = ENV.key?('PB_IGNORE_DEPRECATIONS') ? false : true
   end
 
   def self.print_deprecation_warnings=(value)

data/protobuf.gemspec

@@ -8,8 +8,8 @@ require "protobuf/version"
   s.date          = ::Time.now.strftime('%Y-%m-%d')
   s.license       = 'WTFPL'
 
-  s.authors       = ['BJ Neilsen', 'Brandon Dewitt', 'Devin Christensen']
-  s.email         = ['bj.neilsen+protobuf@gmail.com', 'brandonsdewitt+protobuf@gmail.com', 'quixoten@gmail.com']
+  s.authors       = ['BJ Neilsen', 'Brandon Dewitt', 'Devin Christensen', 'Adam Hutchison']
+  s.email         = ['bj.neilsen+protobuf@gmail.com', 'brandonsdewitt+protobuf@gmail.com', 'quixoten@gmail.com', 'liveh2o@gmail.com']
   s.homepage      = 'https://github.com/localshred/protobuf'
   s.summary       = "Google Protocol Buffers serialization and RPC implementation for Ruby."
   s.description   = s.summary
@@ -19,11 +19,11 @@ require "protobuf/version"
   s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency 'activesupport'
+  s.add_dependency 'activesupport', '>= 3.2'
+  s.add_dependency 'middleware'
   s.add_dependency 'multi_json'
   s.add_dependency 'thor'
 
-  s.add_development_dependency 'eventmachine'
   s.add_development_dependency 'ffi-rzmq'
   s.add_development_dependency 'pry-nav'
   s.add_development_dependency 'rake'
@@ -31,5 +31,5 @@ require "protobuf/version"
   s.add_development_dependency 'simplecov'
   s.add_development_dependency 'yard'
   s.add_development_dependency 'timecop'
-  # s.add_development_dependency 'perftools.rb'
+  s.add_development_dependency 'perftools.rb'
 end