protobuf 2.0.0.rc3 → 2.0.0.rc4

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

@@ -8,43 +8,39 @@ module Protobuf
         include Protobuf::Logger::LogMethods
 
         def send_request
-          check_async
           setup_connection
           connect_to_rpc_server
           post_init
           read_response
         end
 
-        private
-
-        def check_async
-          if async?
-            log_error { "[client-#{self.class}] Cannot run in async mode" }
-            raise "Cannot use Socket client in async mode"
-          end
+        def log_signature
+          @_log_signature ||= "[client-#{self.class}]"
         end
 
+        private
+
         def close_connection
           @socket.close
-          log_debug { "[client-#{self.class}] Connector closed"  }
+          log_debug { sign_message('Connector closed')  }
         end
 
         def connect_to_rpc_server
           @socket = TCPSocket.new(options[:host], options[:port])
-          log_debug { "[client-#{self.class}] Connection established #{options[:host]}:#{options[:port]}"  }
+          log_debug { sign_message("Connection established #{options[:host]}:#{options[:port]}")  }
         end
 
         # Method to determine error state, must be used with Connector api
         def error?
-          return true if(@error)
-          log_debug { "[client-#{self.class}] Error state : #{@socket.closed?}"  }
+          return true if @error
+          log_debug { sign_message("Error state : #{@socket.closed?}")  }
           @socket.closed?
         end
 
         def read_data
           size_io = StringIO.new
 
-          while((size_reader = @socket.getc) != "-")
+          until (size_reader = @socket.getc) == "-"
             size_io << size_reader
           end
           str_size_io = size_io.string
@@ -53,8 +49,8 @@ module Protobuf
         end
 
         def read_response
-          log_debug { "[client-#{self.class}] error? is #{error?}" }
-          return if(error?)
+          log_debug { sign_message("error? is #{error?}") }
+          return if error?
           response_buffer = ::Protobuf::Rpc::Buffer.new(:read)
           response_buffer << read_data
           @stats.response_size = response_buffer.size
@@ -63,12 +59,12 @@ module Protobuf
         end
 
         def send_data
-          return if(error?)
+          return if error?
           request_buffer = ::Protobuf::Rpc::Buffer.new(:write)
           request_buffer.set_data(@request_data)
           @socket.write(request_buffer.write)
           @socket.flush
-          log_debug { "[client-#{self.class}] write closed"  }
+          log_debug { sign_message("write closed") }
         end
 
       end

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

@@ -8,7 +8,6 @@ module Protobuf
         include Protobuf::Logger::LogMethods
 
         def send_request
-          check_async
           setup_connection
           connect_to_rpc_server
           post_init
@@ -19,29 +18,26 @@ module Protobuf
           @zmq_context = nil
         end
 
-        private
-
-        def check_async
-          if async?
-            log_error { "[client-#{self.class}] Cannot run in async mode" }
-            raise "Cannot use Zmq client in async mode" 
-          end
+        def log_signature
+          @_log_signature ||= "[client-#{self.class}]"
         end
 
+        private
+
         def close_connection
-          return if(@error)
+          return if @error
           zmq_error_check(@socket.close)
           zmq_error_check(@zmq_context.terminate)
-          log_debug { "[client-#{self.class}] Connector closed"  }
+          log_debug { sign_message("Connector closed")  }
         end
 
         def connect_to_rpc_server
-          return if(@error)
-          log_debug { "[client-#{self.class} Establishing connection: #{options[:host]}:#{options[:port]}" }
+          return if @error
+          log_debug { sign_message("Establishing connection: #{options[:host]}:#{options[:port]}") }
           @zmq_context = ::ZMQ::Context.new
           @socket = @zmq_context.socket(::ZMQ::REQ)
           zmq_error_check(@socket.connect("tcp://#{options[:host]}:#{options[:port]}"))
-          log_debug { "[client-#{self.class}] Connection established #{options[:host]}:#{options[:port]}" }
+          log_debug { sign_message("Connection established #{options[:host]}:#{options[:port]}") }
         end
 
         # Method to determine error state, must be used with Connector api
@@ -50,18 +46,18 @@ module Protobuf
         end
 
         def read_response
-          return if(@error)
+          return if @error
           @response_data = ''
           zmq_error_check(@socket.recv_string(@response_data))
           parse_response
         end
 
         def send_data
-          return if(@error)
-          log_debug { "[#{log_signature}] Sending Request: %s" % @request_data }
+          return if @error
+          log_debug { sign_message("Sending Request: #{@request_data}") }
           @stats.request_size = @request_data.size
           zmq_error_check(@socket.send_string(@request_data))
-          log_debug { "[client-#{self.class}] write closed" }
+          log_debug { sign_message("write closed") }
         end
 
         def zmq_error_check(return_code)

data/lib/protobuf/rpc/error.rb

@@ -3,16 +3,16 @@ 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) ? ::Protobuf::Socketrpc::ErrorReason.const_get(error_type) : error_type
         super message
       end
-      
+
       def to_response response
         response.error = message
         response.error_reason = @error_type

data/lib/protobuf/rpc/server.rb

@@ -1,140 +1,88 @@
-require 'protobuf/common/logger'
+require 'protobuf/logger'
 require 'protobuf/rpc/rpc.pb'
 require 'protobuf/rpc/buffer'
 require 'protobuf/rpc/error'
 require 'protobuf/rpc/stat'
+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)
+        set_peer
+      end
+
+      def disable_gc!
+        ::GC.disable if ::Protobuf.gc_pause_server_request?
+      end
+
+      def enable_gc!
+        ::GC.enable if ::Protobuf.gc_pause_server_request?
+      end
+
+      # no-op, implemented by including class if desired.
+      def set_peer; end
+
       # Invoke the service method dictated by the proto wrapper request object
       def handle_client
-        # Parse the protobuf request from the socket
-        log_debug { "[#{log_signature}] Parsing request from client" }
         parse_request_from_buffer
+        @dispatcher = ::Protobuf::Rpc::ServiceDispatcher.new(@request)
+        @stats.dispatcher = @dispatcher
 
-        # Determine the service class and method name from the request
-        log_debug { "[#{log_signature}] Extracting procedure call info from request" }
-        parse_service_info
-
-        # Call the service method
-        log_debug { "[#{log_signature}] Dispatching client request to service" }
-        ::GC.disable if ::Protobuf.gc_pause_server_request?
-        invoke_rpc_method
+        disable_gc!
+        @dispatcher.invoke!
+        if @dispatcher.success?
+          @response.response_proto = @dispatcher.response
+        else
+          handle_error(@dispatcher.error)
+        end
       rescue => error
-        # Ensure we're handling any errors that try to slip out the back door
-        log_error(error.message)
-        log_error(error.backtrace.join("\n"))
+        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 { "[#{log_signature}] handle_error: %s" % error.inspect }
+        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.to_s : "RPC_ERROR"
+          code = error.respond_to?(:code) ? error.code : 'RPC_ERROR'
           ::Protobuf::Rpc::PbError.new(message, code).to_response(@response)
         end
       end
 
-      # Assuming all things check out, we can call the service method
-      def invoke_rpc_method
-        # Get a new instance of the service
-        @service = @klass.new
-
-        # Define our response callback to perform the "successful" response to our client
-        # This decouples the service's rpc method from our response to the client,
-        # allowing the service to be the dictator for when the response should be sent back.
-        #
-        # In other words, we don't send the response once the service method finishes executing
-        # since the service may perform it's own operations asynchronously.
-        @service.on_send_response do |response|
-          unless @did_respond
-            parse_response_from_service(response)
-            send_response
-          end
-        end
-
-        @service.on_rpc_failed do |error|
-          unless @did_respond
-            handle_error(error)
-            send_response
-          end
-        end
-
-        # Call the service method
-        log_debug { "[#{log_signature}] Invoking %s#%s with request %s" % [@klass.name, @method, @request.inspect] }
-        @service.__send__(@method, @request)
-      end
-
       def log_signature
-        @log_signature ||= "server-#{self.class}"
+        @_log_signature ||= "[server-#{self.class.name}]"
       end
 
       # Parse the incoming request object into our expected request object
       def parse_request_from_buffer
-        log_debug { "[#{log_signature}] parsing request from buffer: %s" % @request_data }
+        log_debug { sign_message("Parsing request from buffer: #{@request_data}") }
         @request.parse_from_string(@request_data)
       rescue => error
-        exc = ::Protobuf::Rpc::BadRequestData.new 'Unable to parse request: %s' % error.message
+        exc = ::Protobuf::Rpc::BadRequestData.new("Unable to parse request: #{error.message}")
         log_error { exc.message }
         raise exc
       end
 
-      # Read out the response from the service method,
-      # setting it on the pb request, and serializing the
-      # response to the protobuf response wrapper
-      def parse_response_from_service(response)
-        expected = @klass.rpcs[@klass][@method].response_type
-
-        # Cannibalize the response if it's a Hash
-        response = expected.new(response) if response.is_a?(Hash)
-        actual = response.class
-        log_debug { "[#{log_signature}] response (should/actual): %s/%s" % [expected.name, actual.name] }
-
-        # Determine if the service tried to change response types on us
-        if expected != actual
-          raise ::Protobuf::Rpc::BadResponseProto, 'Response proto changed from %s to %s' % [expected.name, actual.name]
-        else
-          @response.response_proto = response
-        end
-      rescue => error
-        log_error error.message
-        log_error error.backtrace.join("\n")
-        handle_error(error)
-      end
-
-      # Parses and returns the service and method name from the request wrapper proto
-      def parse_service_info
-        @klass = @request.service_name.constantize
-        @method = @request.method_name.underscore.to_sym
-
-        unless @klass.instance_methods.include?(@method)
-          raise MethodNotFound, "Service method #{@request.method_name} is not defined by the service"
-        end
-
-        @stats.service = @klass.name
-        @stats.method = @method
-      rescue NameError
-        raise ServiceNotFound, "Service class #{@request.service_name} is not found"
-      end
-
       # Write the response wrapper to the client
       def send_response
-        raise 'Response already sent to client' if @did_respond
-        log_debug { "[#{log_signature}] Sending response to client: %s" % @response.inspect }
+        log_debug { sign_message("Sending response to client: #{@response.inspect}") }
         send_data
-        @stats.end
-        @stats.log_stats
-        @did_respond = true
+        @stats.stop && log_info { @stats.to_s }
       ensure
-        ::GC.enable if ::Protobuf.gc_pause_server_request?
+        enable_gc!
       end
     end
   end
 end
+

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

@@ -9,19 +9,13 @@ module Protobuf
 
         # Initialize a new read buffer for storing client request info
         def post_init
-          log_debug { '[server] Post init, new read buffer created' }
-          @stats = Protobuf::Rpc::Stat.new(:SERVER, true)
-          @stats.client = ::Socket.unpack_sockaddr_in(get_peername)
+          initialize_request!
           @request_buffer = Protobuf::Rpc::Buffer.new(:read)
-          @request = ::Protobuf::Socketrpc::Request.new
-          @response = ::Protobuf::Socketrpc::Response.new
-
-          @did_respond = false
         end
 
         # Receive a chunk of data, potentially flushed to handle_client
         def receive_data(data)
-          log_debug { '[server] receive_data: %s' % data }
+          log_debug { sign_message("receive_data: #{data}") }
 
           @request_buffer << data
           @request_data = @request_buffer.data
@@ -34,9 +28,13 @@ module Protobuf
           response_buffer = Protobuf::Rpc::Buffer.new(:write)
           response_buffer.set_data(@response)
           @stats.response_size = response_buffer.size
-          log_debug { "[#{log_signature}] sending data: #{response_buffer.inspect}" }
+          log_debug { sign_message("sending data: #{response_buffer.inspect}") }
           super(response_buffer.write)
         end
+
+        def set_peer
+          @stats.client = ::Socket.unpack_sockaddr_in(get_peername)
+        end
       end
     end
   end

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

@@ -7,17 +7,6 @@ module Protobuf
       end
 
       def self.run(server)
-        # Ensure errors thrown within EM are caught and logged appropriately
-        #EventMachine.error_handler do |error|
-				#	raise error
-          # if error.message == 'no acceptor'
-        #    raise 'Failed binding to %s:%d (%s)' % [server.host, server.port, error.message]
-          # else
-          #   Protobuf::Logger.error(error.message)
-          #   Protobuf::Logger.error(error.backtrace.join("\n"))
-          # end
-        #end
-
         # Startup and run the rpc server
         ::EventMachine.schedule do
           ::EventMachine.start_server(server.host, server.port, ::Protobuf::Rpc::Evented::Server)

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

@@ -1,5 +1,6 @@
 require 'protobuf/rpc/server'
 require 'protobuf/rpc/servers/socket/worker'
+
 module Protobuf
   module Rpc
     module Socket
@@ -14,7 +15,7 @@ module Protobuf
         end
 
         def self.cleanup_threads
-          log_debug { "[#{log_signature}] Thread cleanup - #{@threads.size} - start" }
+          log_debug { sign_message("Thread cleanup - #{@threads.size} - start") }
 
           @threads = @threads.select do |t|
             if t[:thread].alive?
@@ -26,11 +27,11 @@ module Protobuf
             end
           end
 
-          log_debug { "[#{log_signature}] Thread cleanup - #{@threads.size} - complete" }
+          log_debug { sign_message("Thread cleanup - #{@threads.size} - complete") }
         end
 
         def self.log_signature
-          @log_signature ||= "server-#{self}"
+          @_log_signature ||= "server-#{self.class.name}"
         end
 
         def self.new_worker(socket)
@@ -42,7 +43,7 @@ module Protobuf
         end
 
         def self.run(opts = {})
-          log_debug { "[#{log_signature}] Run" }
+          log_debug { sign_message("Run") }
           host = opts.fetch(:host, "127.0.0.1")
           port = opts.fetch(:port, 9399)
           backlog = opts.fetch(:backlog, 100)
@@ -59,7 +60,7 @@ module Protobuf
           @running = true
 
           while running?
-            log_debug { "[#{log_signature}] Waiting for connections" }
+            log_debug { sign_message("Waiting for connections") }
 
             if ready_cnxns = IO.select(@listen_fds, [], [], auto_collect_timeout)
               cnxns = ready_cnxns.first
@@ -68,13 +69,13 @@ module Protobuf
                 when !running? then
                   # no-op
                 when client == @server then
-                  log_debug { "[#{log_signature}] Accepted new connection" }
+                  log_debug { sign_message("Accepted new connection") }
                   client, sockaddr = @server.accept
                   @listen_fds << client
                 else
                   if !@working.include?(client)
                     @working << @listen_fds.delete(client)
-                    log_debug { "[#{log_signature}] Working"  }
+                    log_debug { sign_message("Working")  }
                     @threads << { :thread => new_worker(client), :socket => client }
 
                     cleanup_threads if cleanup?