protobuf 1.0.1 → 1.1.0.beta0

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

@@ -6,79 +6,71 @@ module Protobuf
     module Connectors
       class EventMachine < Base
         
-        def initialize options
-          super(EMClient::DEFAULT_OPTIONS.merge(options))
-        end
-        
         def send_request
-          Thread.new { EM.run } unless EM.reactor_running?
+          ensure_em_running do 
+            f = Fiber.current
+ 
+            EM.schedule do
+              log_debug "[#{log_signature}] Scheduling EventMachine client request to be created on next tick"
+              cnxn = EMClient.connect(options, &ensure_cb)
+              cnxn.on_success(&success_cb) if success_cb
+              cnxn.on_failure(&ensure_cb)
+              cnxn.on_complete { resume_fiber(f) } unless async?
+              log_debug "[#{log_signature}] Connection scheduled"
+            end
 
-          f = Fiber.current
-        
-          EM.schedule do
-            log_debug '[client] Scheduling EventMachine client request to be created on next tick'
-            cnxn = EMClient.connect options, &ensure_cb
-            cnxn.on_success &success_cb if success_cb
-            cnxn.on_failure &ensure_cb
-            cnxn.on_complete { resume_fiber f } unless async?
-            log_debug '[client] Connection scheduled'
+            async? ? true : set_timeout_and_validate_fiber
           end
-
-          return set_timeout_and_validate_fiber unless async?
-          return true
         end
         
-        # Returns a proc that ensures any errors will be returned to the client
+        # Returns a callable that ensures any errors will be returned to the client
         # 
         # If a failure callback was set, just use that as a direct assignment
         # otherwise implement one here that simply throws an exception, since we
         # don't want to swallow the black holes.
         # 
         def ensure_cb
-          @ensure_cb ||= begin
-            cbk = nil
-            if @failure_cb
-              cbk = @failure_cb
-            else
-              cbk = proc do |error|
-                raise '%s: %s' % [error.code.name, error.message]
-              end
-            end
-            cbk
-          end
+          @ensure_cb ||= (@failure_cb || lambda { |error| raise '%s: %s' % [error.code.name, error.message] } )
+        end
+
+        def log_signature
+          @log_signature ||= "client-#{self.class}"
         end
       
         private
 
-        def set_timeout_and_validate_fiber
-          @timeout_timer = EM::add_timer(@options[:timeout]) do
-            message = 'Client timeout of %d seconds expired' % @options[:timeout]
-            err = ClientError.new(Protobuf::Socketrpc::ErrorReason::RPC_ERROR, message)
-            ensure_cb.call(err)
-          end
-
-          Fiber.yield
-        rescue FiberError
-          message = "Synchronous calls must be in 'EM.fiber_run' block" 
-          err = ClientError.new(Protobuf::Socketrpc::ErrorReason::RPC_ERROR, message)
-          ensure_cb.call(err)
+        def ensure_em_running(&blk)
+          EM.reactor_running? ? yield : EM.fiber_run { blk.call; EM.stop }
         end
 
         def resume_fiber(fib)
           EM::cancel_timer(@timeout_timer)
           fib.resume(true)
         rescue => ex 
-          log_error 'An exception occurred while waiting for server response:'
+          log_error "[#{log_signature}] An exception occurred while waiting for server response:"
           log_error ex.message
           log_error ex.backtrace.join("\n")
 
           message = 'Synchronous client failed: %s' % ex.message
-          err = ClientError.new(Protobuf::Socketrpc::ErrorReason::RPC_ERROR, message)
+          err = Protobuf::Rpc::ClientError.new(Protobuf::Socketrpc::ErrorReason::RPC_ERROR, message)
           ensure_cb.call(err)
         end
 
+        def set_timeout_and_validate_fiber
+          @timeout_timer = EM::add_timer(@options[:timeout]) do
+            message = 'Client timeout of %d seconds expired' % @options[:timeout]
+            err = Protobuf::Rpc::ClientError.new(Protobuf::Socketrpc::ErrorReason::RPC_ERROR, message)
+            ensure_cb.call(err)
+          end
+
+          Fiber.yield
+        rescue FiberError
+          message = "Synchronous calls must be in 'EM.fiber_run' block" 
+          err = Protobuf::Rpc::ClientError.new(Protobuf::Socketrpc::ErrorReason::RPC_ERROR, message)
+          ensure_cb.call(err)
+        end
 
       end
     end
   end
-end
+end

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

@@ -4,10 +4,67 @@ module Protobuf
   module Rpc
     module Connectors
       class Socket < Base
+        include Protobuf::Rpc::Connectors::Common
+        include Protobuf::Logger::LogMethods
         
         def send_request
+          check_async
+          initialize_stats
+          connect_to_rpc_server
+          post_init # calls _send_request
+          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" 
+          else
+            log_debug "[client-#{self.class}] Async check passed" 
+         end
+        end
+
+        def close_connection
+          @socket.close
+          log_debug "[client-#{self.class}] 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]}" 
+        end
+
+        # Method to determine error state, must be used with Connector api
+        def error?
+          log_debug "[client-#{self.class}] Error state : #{@socket.closed?}" 
+          @socket.closed?
+        end
+
+        def read_data
+          size_io = StringIO.new
+
+          while((size_reader = @socket.getc) != "-")
+            size_io << size_reader
+          end
+          str_size_io = size_io.string
+
+          "#{str_size_io}-#{@socket.read(str_size_io.to_i)}"
+        end
+
+        def read_response
+          @buffer << read_data 
+          parse_response if @buffer.flushed?
+        end
+
+        def send_data(data)
+          @socket.write(data)
+          @socket.flush
+          @socket.close_write
+          log_debug "[client-#{self.class}] write closed" 
+        end
+
       end
     end
   end

data/lib/protobuf/rpc/error.rb

@@ -2,20 +2,9 @@ require 'protobuf/rpc/rpc.pb'
 
 module Protobuf
   module Rpc
+    ClientError = Struct.new("ClientError", :code, :message)
     
-    autoload :BadRequestData, 'protobuf/rpc/error/server_error'
-    autoload :BadRequestProto, 'protobuf/rpc/error/server_error'
-    autoload :ServiceNotFound, 'protobuf/rpc/error/server_error'
-    autoload :MethodNotFound, 'protobuf/rpc/error/server_error'
-    autoload :RpcError, 'protobuf/rpc/error/server_error'
-    autoload :RpcFailed, 'protobuf/rpc/error/server_error'
-    
-    autoload :InvalidRequestProto, 'protobuf/rpc/error/client_error'
-    autoload :BadResponseProto, 'protobuf/rpc/error/client_error'
-    autoload :UnknownHost, 'protobuf/rpc/error/client_error'
-    autoload :IOError, 'protobuf/rpc/error/client_error'
-    
-    # Base RpcError class for client and server errors
+    # Base PbError class for client and server errors
     class PbError < StandardError
       attr_reader :error_type
       
@@ -31,4 +20,7 @@ module Protobuf
     end
     
   end
-end
+end
+
+require 'protobuf/rpc/error/server_error'
+require 'protobuf/rpc/error/client_error'

data/lib/protobuf/rpc/server.rb

@@ -1,5 +1,3 @@
-require 'eventmachine'
-require 'socket'
 require 'protobuf/common/logger'
 require 'protobuf/rpc/rpc.pb'
 require 'protobuf/rpc/buffer'
@@ -8,26 +6,7 @@ require 'protobuf/rpc/stat'
 
 module Protobuf
   module Rpc
-    class Server < EventMachine::Connection
-      include Protobuf::Logger::LogMethods
-      
-      # 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)
-        
-        @buffer = Protobuf::Rpc::Buffer.new :read
-        @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
-        @buffer << data
-        handle_client if @buffer.flushed?
-      end
+    module Server 
       
       # Invoke the service method dictated by the proto wrapper request object
       def handle_client
@@ -38,17 +17,16 @@ module Protobuf
         @response = Protobuf::Socketrpc::Response.new
         
         # Parse the protobuf request from the socket
-        log_debug '[server] Parsing request from client'
+        log_debug "[#{log_signature}] Parsing request from client"
         parse_request_from_buffer
       
         # Determine the service class and method name from the request
-        log_debug '[server] Extracting procedure call info from request'
+        log_debug "[#{log_signature}] Extracting procedure call info from request"
         parse_service_info
         
         # Call the service method
-        log_debug '[server] Dispatching client request to service'
+        log_debug "[#{log_signature}] Dispatching client request to service"
         invoke_rpc_method
-        
       rescue => error
         # Ensure we're handling any errors that try to slip out the back door
         log_error error.message
@@ -56,8 +34,18 @@ module Protobuf
         handle_error(error)
         send_response
       end
-      
-      private
+
+      # 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
+        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"
+          PbError.new(message, code).to_response(@response)
+        end
+      end
       
       # Assuming all things check out, we can call the service method
       def invoke_rpc_method
@@ -85,99 +73,84 @@ module Protobuf
         end
         
         # Call the service method
-        log_debug '[server] Invoking %s#%s with request %s' % [@klass.name, @method, @request.inspect]
-        @service.__send__ @method, @request
+        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}"
       end
       
       # Parse the incoming request object into our expected request object
       def parse_request_from_buffer
-        begin
-          log_debug '[server] parsing request from buffer: %s' % @buffer.data.inspect
-          @request.parse_from_string @buffer.data
-        rescue => error
-          exc = BadRequestData.new 'Unable to parse request: %s' % error.message
-          log_error exc.message
-          raise exc
-        end
+        log_debug "[#{log_signature}] parsing request from buffer: %s" % @buffer.data.inspect
+        @request.parse_from_string(@buffer.data)
+      rescue => error
+        exc = BadRequestData.new 'Unable to parse request: %s' % 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
-        begin
-          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 '[server] response (should/actual): %s/%s' % [expected.name, actual.name]
-          
-          # Determine if the service tried to change response types on us
-          if expected == actual
-            begin
-              # Response types match, so go ahead and serialize
-              log_debug '[server] serializing response: %s' % response.inspect
-              @response.response_proto = response.serialize_to_string
-            rescue
-              raise BadResponseProto, $!.message
-            end
-          else
-            # response types do not match, throw the appropriate error
-            raise BadResponseProto, 'Response proto changed from %s to %s' % [expected.name, actual.name]
-          end
-        rescue => error
-          log_error error.message
-          log_error error.backtrace.join("\n")
-          handle_error(error)
-        end
-      end
-      
-      # Write the response wrapper to the client
-      def send_response
-        raise 'Response already sent to client' if @did_respond
-        log_debug '[server] Sending response to client: %s' % @response.inspect
-        response_buffer = Protobuf::Rpc::Buffer.new(:write, @response)
-        send_data(response_buffer.write)
-        @stats.response_size = response_buffer.size
-        @stats.end
-        @stats.log_stats
-        @did_respond = true
-      end
-      
-      # Client error handler. Receives an exception object and writes it into the @response
-      def handle_error error
-        log_debug '[server] handle_error: %s' % error.inspect
-        if error.is_a? PbError
-          error.to_response @response
-        elsif error.is_a? ClientError
-          PbError.new(error.message, error.code.to_s).to_response @response
+      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
+          serialize_response(response)
         else
-          message = error.is_a?(String) ? error : error.message
-          PbError.new(message, 'RPC_ERROR').to_response @response
+          # response types do not match, throw the appropriate error
+          raise BadResponseProto, 'Response proto changed from %s to %s' % [expected.name, actual.name]
         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, @method = nil, nil
-        
-        begin
-          @klass = Util.constantize(@request.service_name)
-        rescue
-          raise ServiceNotFound, "Service class #{@request.service_name} is not found"
-        end
-        
+        @klass = Util.constantize(@request.service_name)
         @method = Util.underscore(@request.method_name).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
+        response_buffer = Protobuf::Rpc::Buffer.new(:write, @response)
+        send_data(response_buffer.write)
+        @stats.response_size = response_buffer.size
+        @stats.end
+        @stats.log_stats
+        @did_respond = true
+      end
+
+      def serialize_response(response)
+        log_debug "[#{log_signature}] serializing response: %s" % response.inspect
+        @response.response_proto = response.serialize_to_string
+      rescue
+        raise BadResponseProto, $!.message
       end
       
     end
+
   end
+
 end

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

@@ -0,0 +1,32 @@
+module Protobuf
+  module Rpc
+    class EventedRunner 
+
+      def self.stop
+        EventMachine.stop_event_loop if EventMachine.reactor_running?
+        Protobuf::Logger.info 'Shutdown complete'
+      end
+
+      def self.run(server)
+        # Ensure errors thrown within EM are caught and logged appropriately
+        EventMachine.error_handler do |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
+        EM.schedule do
+          EventMachine.start_server(server.host, server.port, Protobuf::Rpc::EventedServer) && \
+            Protobuf::Logger.info('RPC Server listening at %s:%d in %s' % [server.host, server.port, server.env])
+        end
+
+        # Join or start the reactor
+        EM.reactor_running? ? EM.reactor_thread.join : EM.run
+      end
+    end
+  end
+end