protobuf 1.1.3 → 1.3.0

data/lib/protobuf/rpc/client.rb

@@ -29,7 +29,7 @@ module Protobuf
       def initialize(opts={})
         raise "Invalid client configuration. Service must be defined." if opts[:service].nil?
         @connector = Connector.connector_for_client.new(opts)
-        log_debug "[#{log_signature}] Initialized with options: %s" % opts.inspect
+        log_debug { "[#{log_signature}] Initialized with options: %s" % opts.inspect }
       end
 
       def log_signature
@@ -109,25 +109,25 @@ module Protobuf
       def method_missing(method, *params)
         service = options[:service]
         unless service.rpcs[service].keys.include?(method)
-          log_error "[#{log_signature}] %s#%s not rpc method, passing to super" % [service.name, method.to_s]
+          log_error { "[#{log_signature}] %s#%s not rpc method, passing to super" % [service.name, method.to_s] }
           super(method, *params)
         else
-          log_debug "[#{log_signature}] %s#%s" % [service.name, method.to_s]
+          log_debug { "[#{log_signature}] %s#%s" % [service.name, method.to_s] }
           rpc = service.rpcs[service][method.to_sym]
           options[:request_type] = rpc.request_type
-          log_debug "[#{log_signature}] Request Type: %s" % options[:request_type].name
+          log_debug { "[#{log_signature}] Request Type: %s" % options[:request_type].name }
           options[:response_type] = rpc.response_type
-          log_debug "[#{log_signature}] Response Type: %s" % options[:response_type].name
+          log_debug { "[#{log_signature}] Response Type: %s" % options[:response_type].name }
           options[:method] = method.to_s
           options[:request] = params[0].is_a?(Hash) ? options[:request_type].new(params[0]) : params[0]
-          log_debug "[#{log_signature}] Request Data: %s" % options[:request].inspect
+          log_debug { "[#{log_signature}] Request Data: %s" % options[:request].inspect }
           
           # Call client to setup on_success and on_failure event callbacks
           if block_given?
-            log_debug "[#{log_signature}] client setup callback given, invoking"
+            log_debug { "[#{log_signature}] client setup callback given, invoking" }
             yield(self)
           else
-            log_debug "[#{log_signature}] no block given for callbacks"
+            log_debug { "[#{log_signature}] no block given for callbacks" }
           end
       
           send_request

data/lib/protobuf/rpc/connector.rb

@@ -7,6 +7,8 @@ module Protobuf
           case Protobuf::ClientType 
           when "Socket" then 
             ::Protobuf::Rpc::Connectors::Socket
+          when "Zmq" then
+            ::Protobuf::Rpc::Connectors::Zmq
           else
             ::Protobuf::Rpc::Connectors::EventMachine
           end

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

@@ -37,7 +37,6 @@ module Protobuf
         def async?
           !!@options[:async]
         end
-        
       end
     end
   end

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

@@ -1,8 +1,8 @@
 module Protobuf
-  module Rpc 
+  module Rpc
     module Connectors
-      module Common 
-        
+      module Common
+
         attr_reader :error
 
         def any_callbacks?
@@ -14,30 +14,34 @@ module Protobuf
         def complete
           @stats.end
           @stats.log_stats
-          log_debug "[#{log_signature}] Response proceessing complete"
+          log_debug { "[#{log_signature}] Response proceessing complete" }
           @complete_cb.call(self) unless @complete_cb.nil?
         rescue
-          log_error "[#{log_signature}] Complete callback error encountered: %s" % $!.message
-          log_error "[#{log_signature}] %s" % $!.backtrace.join("\n")
+          log_error { "[#{log_signature}] Complete callback error encountered: %s" % $!.message }
+          log_error { "[#{log_signature}] %s" % $!.backtrace.join("\n") }
           raise
         end
 
         def data_callback(data)
-          log_debug "[#{log_signature}] Using data_callback"
+          log_debug { "[#{log_signature}] Using data_callback" }
           @used_data_callback = true
           @data = data
         end
 
+        # All failures should be routed through this method
+        #
+        # @param [Symbol] code The code we're using (see ::Protobuf::Socketrpc::ErrorReason)
+        # @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.message = message
-          log_debug "[#{log_signature}] Server failed request (invoking on_failure): %s" % @error.inspect
-          
+          log_debug { "[#{log_signature}] Server failed request (invoking on_failure): %s" % @error.inspect }
+
           @failure_cb.call(@error) unless @failure_cb.nil?
         rescue
-          log_error "[#{log_signature}] Failure callback error encountered: %s" % $!.message
-          log_error "[#{log_signature}] %s" % $!.backtrace.join("\n")
+          log_error { "[#{log_signature}] Failure callback error encountered: %s" % $!.message }
+          log_error { "[#{log_signature}] %s" % $!.backtrace.join("\n") }
           raise
         ensure
           complete
@@ -47,10 +51,9 @@ module Protobuf
           @stats = Protobuf::Rpc::Stat.new(:CLIENT, true)
           @stats.server = [@options[:port], @options[:host]]
           @stats.service = @options[:service].name
-          @stats.method = @options[:method]
-          self
+          @stats.method = @options[:method].to_s
         rescue => ex
-          fail(:RPC_ERROR, "Invalid stats configuration. #{ex.message}") 
+          fail(:RPC_ERROR, "Invalid stats configuration. #{ex.message}")
         end
 
         def log_signature
@@ -61,22 +64,21 @@ module Protobuf
           # Close up the connection as we no longer need it
           close_connection
 
-          log_debug "[#{log_signature}] Parsing response from server (connection closed)"
-          @stats.response_size = @buffer.size
+          log_debug { "[#{log_signature}] Parsing response from server (connection closed)" }
 
           # Parse out the raw response
           response_wrapper = Protobuf::Socketrpc::Response.new
-          response_wrapper.parse_from_string(@buffer.data)
+          response_wrapper.parse_from_string(@response_data)
 
           # Determine success or failure based on parsed data
           if response_wrapper.has_field?(:error_reason)
-            log_debug "[#{log_signature}] Error response parsed"
+            log_debug { "[#{log_signature}] Error response parsed" }
 
             # fail the call if we already know the client is failed
             # (don't try to parse out the response payload)
             fail(response_wrapper.error_reason, response_wrapper.error)
           else
-            log_debug "[#{log_signature}] Successful response parsed"
+            log_debug { "[#{log_signature}] Successful response parsed" }
 
             # Ensure client_response is an instance
             response_type = @options[:response_type].new
@@ -92,52 +94,51 @@ module Protobuf
           end
         end
 
-        # Setup the read buffer for data coming back
         def post_init
-          # Setup an object for reponses without callbacks
-          @data = nil
-          log_debug "[#{log_signature}] Post init, new read buffer created"
-          @buffer = Protobuf::Rpc::Buffer.new(:read)
-          _send_request unless error?
-          log_debug "[#{log_signature}] Post init, new read buffer created just sent"
+          send_data unless error?
         rescue
           fail(:RPC_ERROR, 'Connection error: %s' % $!.message)
         end
 
-        # Sends the request to the server, invoked by the connection_completed event
-        def _send_request
-          request_wrapper = Protobuf::Socketrpc::Request.new
-          request_wrapper.service_name = @options[:service].name
-          request_wrapper.method_name = @options[:method].to_s
+        def rpc_request_data
+          validate_request_type
 
-          if @options[:request].class == @options[:request_type]
-            request_wrapper.request_proto = @options[:request].serialize_to_string
-          else
-            expected = @options[:request_type].name
-            actual = @options[:request].class.name
-            fail :INVALID_REQUEST_PROTO, 'Expected request type to be type of %s, got %s instead' % [expected, actual]
-          end
+          return Protobuf::Socketrpc::Request.new(
+            :service_name => @options[:service].name,
+            :method_name => @options[:method].to_s,
+            :request_proto => @options[:request].serialize_to_string
+          ).serialize_to_string
+        rescue
+          fail :INVALID_REQUEST_PROTO, "Could not set request proto: #{$!.message}"
+        end
 
-          log_debug "[#{log_signature}] Sending Request: %s" % request_wrapper.inspect
-          request_buffer = Protobuf::Rpc::Buffer.new(:write, request_wrapper)
-          @stats.request_size = request_buffer.size
-          send_data(request_buffer.write)
+        def setup_connection
+          initialize_stats
+          @request_data = rpc_request_data
         end
 
         def succeed(response)
-          log_debug "[#{log_signature}] Server succeeded request (invoking on_success)"
+          log_debug { "[#{log_signature}] Server succeeded request (invoking on_success)" }
           @success_cb.call(response) unless @success_cb.nil?
         rescue
-          log_error "[#{log_signature}] Success callback error encountered: %s" % $!.message
-          log_error "[#{log_signature}] %s" % $!.backtrace.join("\n")
+          log_error { "[#{log_signature}] Success callback error encountered: %s" % $!.message }
+          log_error { "[#{log_signature}] %s" % $!.backtrace.join("\n") }
           fail :RPC_ERROR, 'An exception occurred while calling on_success: %s' % $!.message
-        ensure 
+        ensure
           complete
         end
 
+        def validate_request_type
+          unless @options[:request].class == @options[:request_type]
+            expected = @options[:request_type].name
+            actual = @options[:request].class.name
+            fail :INVALID_REQUEST_PROTO, 'Expected request type to be type of %s, got %s instead' % [expected, actual]
+          end
+        end
+
         def verify_callbacks
           if !any_callbacks?
-            log_debug "[#{log_signature}] No callbacks set, using data_callback"
+            log_debug { "[#{log_signature}] No callbacks set, using data_callback" }
             @success_cb = @failure_cb = self.method(:data_callback)
           end
         end
@@ -148,7 +149,6 @@ module Protobuf
             fail(:RPC_ERROR, "Invalid client connection configuration. #{opt} must be a defined option.") if @options[opt].nil?
           end
         end
-
       end
     end
   end

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

@@ -2,56 +2,82 @@
 module Protobuf
   module Rpc
     module Connectors
-    
+
       class EMClient < EM::Connection
         include Protobuf::Logger::LogMethods
         include Protobuf::Rpc::Connectors::Common
-      
+
         attr_reader :options, :request, :response
         attr_reader :error, :error_reason, :error_message
-      
-       class << self
-
-          def connect(options={})
-            options = DEFAULT_OPTIONS.merge(options)
-            log_debug "[client-#{self}] Connecting to server: %s" % options.inspect
-            EM.connect(options[:host], options[:port], self, options)
-          end
 
-        end
-       
+        ##
+        # Constructor
+        #
         def initialize(options={}, &failure_cb)
           @failure_cb = failure_cb
           @options = DEFAULT_OPTIONS.merge(options)
+          @response_buffer = ::Protobuf::Rpc::Buffer.new(:read)
           verify_options
-          initialize_stats
 
-          log_debug "[#{log_signature}] Client Initialized: %s" % options.inspect
+          log_debug { "[#{log_signature}] Client Initialized: %s" % options.inspect }
         rescue
           fail(:RPC_ERROR, 'Failed to initialize connection: %s' % $!.message)
         end
 
-        # Success callback registration
-        def on_success(&success_cb)
-          @success_cb = success_cb
+        ##
+        # Class Methods
+        #
+        def self.connect(options={})
+          options = DEFAULT_OPTIONS.merge(options)
+          log_debug { "[client-#{self}] Connecting to server: %s" % options.inspect }
+          EM.connect(options[:host], options[:port], self, options)
         end
-      
-        # Failure callback registration
-        def on_failure(&failure_cb)
-          @failure_cb = failure_cb
+
+        # turn post_init back into a no-op for event machine
+        def post_init
         end
-      
+
+        ##
+        # Instance Methods
+        #
         # Completion callback registration
         def on_complete(&complete_cb)
           @complete_cb = complete_cb
         end
-      
+
+        # Failure callback registration
+        def on_failure(&failure_cb)
+          @failure_cb = failure_cb
+        end
+
+        # Success callback registration
+        def on_success(&success_cb)
+          @success_cb = success_cb
+        end
+
         def receive_data(data)
-          log_debug "[#{log_signature}] receive_data: %s" % data
-          @buffer << data
-          parse_response if @buffer.flushed?
+          log_debug { "[#{log_signature}] receive_data: %s" % data }
+          @response_buffer << data
+          @response_data = @response_buffer.data
+          parse_response if(!@response_data.nil? && @response_buffer.flushed?)
         end
-     
+
+        def send_data
+          request_buffer = ::Protobuf::Rpc::Buffer.new(:write)
+          request_buffer.set_data(@request_data)
+          log_debug { "[#{log_signature}] sending data: #{request_buffer.inspect}" }
+          super(request_buffer.write)
+        rescue
+          fail(:RPC_ERROR, 'Connection error: %s' % $!.message)
+        end
+
+        # overwriting this method for java because it's broken in eventmachine. See https://github.com/eventmachine/eventmachine/issues/14
+        if RUBY_PLATFORM =~ /java/
+          def error?
+            !!@error
+          end
+        end
+
       end
     end
   end

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

@@ -11,12 +11,14 @@ module Protobuf
             f = Fiber.current
 
             EM.next_tick do
-              log_debug "[#{log_signature}] Scheduling EventMachine client request to be created on next tick"
+              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"
+              cnxn.setup_connection
+              cnxn.send_data
+              log_debug { "[#{log_signature}] Connection scheduled" }
             end
 
             async? ? true : set_timeout_and_validate_fiber
@@ -41,10 +43,10 @@ module Protobuf
 
         def ensure_em_running(&blk)
           if EM.reactor_running? 
-            @global_reactor = true
+            @using_global_reactor = true
             yield
           else 
-            @global_reactor = false
+            @using_global_reactor = false
             EM.fiber_run do 
               blk.call
               EM.stop
@@ -56,32 +58,27 @@ module Protobuf
           EM::cancel_timer(@timeout_timer)
           fib.resume(true)
         rescue => ex 
-          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 = Protobuf::Rpc::ClientError.new(Protobuf::Socketrpc::ErrorReason::RPC_ERROR, message)
-          ensure_cb.call(err)
-          EM.stop if !@global_reactor
+          error_stop_reactor(message)
         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)
-            EM.stop if !@global_reactor
+            error_stop_reactor(message)
           end
 
           Fiber.yield
         rescue FiberError
           message = "Synchronous calls must be in 'EM.fiber_run' block" 
+          error_stop_reactor(message)
+        end
+
+        def error_stop_reactor(message)
           err = Protobuf::Rpc::ClientError.new(Protobuf::Socketrpc::ErrorReason::RPC_ERROR, message)
           ensure_cb.call(err)
-          EM.stop if !@global_reactor
-       end
-
+          EM.stop unless @using_global_reactor
+        end
       end
     end
   end

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

@@ -6,12 +6,12 @@ module Protobuf
       class Socket < Base
         include Protobuf::Rpc::Connectors::Common
         include Protobuf::Logger::LogMethods
-        
+
         def send_request
           check_async
-          initialize_stats
+          setup_connection
           connect_to_rpc_server
-          post_init # calls _send_request
+          post_init
           read_response
         end
 
@@ -19,26 +19,25 @@ module Protobuf
 
         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
+            log_error { "[client-#{self.class}] Cannot run in async mode" }
+            raise "Cannot use Socket client in async mode"
+          end
         end
 
         def close_connection
           @socket.close
-          log_debug "[client-#{self.class}] Connector closed" 
+          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]}" 
+          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?}" 
+          return true if(@error)
+          log_debug { "[client-#{self.class}] Error state : #{@socket.closed?}"  }
           @socket.closed?
         end
 
@@ -54,14 +53,22 @@ module Protobuf
         end
 
         def read_response
-          @buffer << read_data 
-          parse_response if @buffer.flushed?
+          log_debug { "[client-#{self.class}] error? is #{error?}" }
+          return if(error?)
+          response_buffer = ::Protobuf::Rpc::Buffer.new(:read)
+          response_buffer << read_data
+          @stats.response_size = response_buffer.size
+          @response_data = response_buffer.data
+          parse_response if response_buffer.flushed?
         end
 
-        def send_data(data)
-          @socket.write(data)
+        def send_data
+          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 { "[client-#{self.class}] write closed"  }
         end
 
       end