protobuf 1.4.2 → 2.0.0.rc1

data/lib/protobuf/rpc/buffer.rb

@@ -44,7 +44,7 @@ module Protobuf
       end
 
       def set_data(data)
-        @data = data.is_a?(Protobuf::Message) ? data.serialize_to_string : data.to_s
+        @data = data.is_a?(::Protobuf::Message) ? data.serialize_to_string : data.to_s
         @size = @data.size
       end
 

data/lib/protobuf/rpc/client.rb

@@ -9,14 +9,14 @@ module Protobuf
     class Client
       extend Forwardable
       include Protobuf::Logger::LogMethods
-      
+
       delegate [:options, :complete_cb, :success_cb, :failure_cb, :async?] => :@connector
       attr_reader :connector
-      
+
       # Create a new client with default options (defined in ClientConnection)
       # See Service#client for a more convenient way to create a client, as well
       # as Client#method_missing defined below.
-      # 
+      #
       #   request = WidgetFindRequest.new
       #   client = Client.new({
       #     :service => WidgetService,
@@ -35,33 +35,33 @@ module Protobuf
       def log_signature
         @log_signature ||= "client-#{self.class}"
       end
-      
-      # Set a complete callback on the client to return the object (self). 
+
+      # Set a complete callback on the client to return the object (self).
       # Callback is called regardless of :async setting.
-      # 
+      #
       #   client = Client.new(:service => WidgetService)
       #   client.on_complete {|obj| ... }
-      # 
+      #
       def on_complete(&complete_cb)
-        @connector.complete_cb = complete_cb 
+        @connector.complete_cb = complete_cb
       end
 
       def on_complete=(callable)
         if callable != nil && !callable.respond_to?(:call) && callable.arity != 1
           raise "callable must take a single argument and respond to :call"
         end
-        
-        @connector.complete_cb = callable 
+
+        @connector.complete_cb = callable
       end
-      
+
       # Set a failure callback on the client to return the
       # error returned by the service, if any. If this callback
       # is called, success_cb will NOT be called.
       # Callback is called regardless of :async setting.
-      # 
+      #
       #   client = Client.new(:service => WidgetService)
       #   client.on_failure {|err| ... }
-      # 
+      #
       def on_failure(&failure_cb)
         @connector.failure_cb = failure_cb
       end
@@ -71,17 +71,17 @@ module Protobuf
           raise "callable must take a single argument and respond to :call"
         end
 
-        @connector.failure_cb = callable 
+        @connector.failure_cb = callable
       end
-      
+
       # Set a success callback on the client to return the
       # successful response from the service when it is returned.
       # If this callback is called, failure_cb will NOT be called.
       # Callback is called regardless of :async setting.
-      # 
+      #
       #   client = Client.new(:service => WidgetService)
       #   client.on_success {|res| ... }
-      # 
+      #
       def on_success(&success_cb)
         @connector.success_cb = success_cb
       end
@@ -91,9 +91,9 @@ module Protobuf
           raise "callable must take a single argument and respond to :call"
         end
 
-        @connector.success_cb = callable 
+        @connector.success_cb = callable
       end
-      
+
       # Provides a mechanism to call the service method against the client
       # which will automatically setup the service_class and method_name
       # in the wrapper protobuf request.
@@ -105,7 +105,7 @@ module Protobuf
       #     c.on_success {|res| ... }
       #     c.on_failure {|err| ... }
       #   end
-      # 
+      #
       def method_missing(method, *params)
         service = options[:service]
         unless service.rpcs[service].keys.include?(method)
@@ -121,7 +121,7 @@ module Protobuf
           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 }
-          
+
           # Call client to setup on_success and on_failure event callbacks
           if block_given?
             log_debug { "[#{log_signature}] client setup callback given, invoking" }
@@ -129,11 +129,11 @@ module Protobuf
           else
             log_debug { "[#{log_signature}] no block given for callbacks" }
           end
-      
+
           send_request
         end
       end
-      
+
       # Send the request to the service through eventmachine.
       # This method is usually never called directly
       # but is invoked by method_missing (see docs above).
@@ -146,7 +146,7 @@ module Protobuf
       #     :response_type => "WidgetList",
       #     :request => request
       #   })
-      # 
+      #
       #   client.on_success do |res|
       #     res.widgets.each{|w| puts w.inspect }
       #   end
@@ -154,13 +154,13 @@ module Protobuf
       #   client.on_failure do |err|
       #     puts err.message
       #   end
-      # 
+      #
       #   client.send_request
       #
       def send_request
         @connector.send_request
       end
-      
+
     end
   end
 end

data/lib/protobuf/rpc/connector.rb

@@ -1,22 +1,23 @@
 module Protobuf
   module Rpc
     class Connector
-      
-      def self.connector_for_client
-        if defined?(Protobuf::ClientType)
-          case Protobuf::ClientType 
-          when "Socket" then 
-            ::Protobuf::Rpc::Connectors::Socket
-          when "Zmq" then
-            ::Protobuf::Rpc::Connectors::Zmq
-          else
-            ::Protobuf::Rpc::Connectors::EventMachine
-          end
-        else
-          ::Protobuf::Rpc::Connectors::EventMachine
+
+      # Returns a connector class for the pre-defined connector_type.
+      def self.connector_for_client(reload = false)
+        if reload || @_connector.nil?
+          @_connector = case ::Protobuf.connector_type
+                        when :evented then
+                          ::Protobuf::Rpc::Connectors::EventMachine
+                        when :zmq then
+                          ::Protobuf::Rpc::Connectors::Zmq
+                        else
+                          ::Protobuf::Rpc::Connectors::Socket
+                        end
         end
+
+        return @_connector
       end
-      
+
     end
   end
 end

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

@@ -7,10 +7,10 @@ module Protobuf
       class EventMachine < Base
 
         def send_request
-          ensure_em_running do 
+          ensure_em_running do
             f = Fiber.current
 
-            EM.next_tick do
+            ::EM.next_tick 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
@@ -26,11 +26,11 @@ module Protobuf
         end
 
         # 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 ||= (@failure_cb || lambda { |error| raise '%s: %s' % [error.code.name, error.message] } )
         end
@@ -42,42 +42,42 @@ module Protobuf
         private
 
         def ensure_em_running(&blk)
-          if EM.reactor_running? 
+          if ::EM.reactor_running?
             @using_global_reactor = true
             yield
-          else 
+          else
             @using_global_reactor = false
-            EM.fiber_run do 
+            ::EM.fiber_run do
               blk.call
-              EM.stop
+              ::EM.stop
             end
           end
         end
 
         def resume_fiber(fib)
-          EM::cancel_timer(@timeout_timer)
+          ::EM::cancel_timer(@timeout_timer)
           fib.resume(true)
-        rescue => ex 
+        rescue => ex
           message = 'Synchronous client failed: %s' % ex.message
           error_stop_reactor(message)
         end
 
         def set_timeout_and_validate_fiber
-          @timeout_timer = EM::add_timer(@options[:timeout]) do
+          @timeout_timer = ::EM::add_timer(@options[:timeout]) do
             message = 'Client timeout of %d seconds expired' % @options[:timeout]
             error_stop_reactor(message)
           end
 
           Fiber.yield
         rescue FiberError
-          message = "Synchronous calls must be in 'EM.fiber_run' block" 
+          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 unless @using_global_reactor
+          ::EM.stop unless @using_global_reactor
         end
       end
     end

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

@@ -73,35 +73,46 @@
 #   UNKNOWN_HOST = 8; // Could not find supplied host
 #   IO_ERROR = 9; // I/O error while communicating with server
 # }
-
-require 'protobuf/message/message'
-require 'protobuf/message/enum'
-require 'protobuf/message/extend'
+require 'protobuf/message'
 
 module Protobuf
   module Socketrpc
-    class Request < ::Protobuf::Message
-      required :string, :service_name, 1
-      required :string, :method_name, 2
-      required :bytes, :request_proto, 3
-    end
-    class Response < ::Protobuf::Message
-      optional :bytes, :response_proto, 1
-      optional :string, :error, 2
-      optional :bool, :callback, 3, :default => false
-      optional :ErrorReason, :error_reason, 4
-    end
-    class ErrorReason < ::Protobuf::Enum
-      define :BAD_REQUEST_DATA, 0
-      define :BAD_REQUEST_PROTO, 1
-      define :SERVICE_NOT_FOUND, 2
-      define :METHOD_NOT_FOUND, 3
-      define :RPC_ERROR, 4
-      define :RPC_FAILED, 5
-      define :INVALID_REQUEST_PROTO, 6
-      define :BAD_RESPONSE_PROTO, 7
-      define :UNKNOWN_HOST, 8
-      define :IO_ERROR, 9
-    end
+    ##
+    # Enum Classes
+    #
+    class ErrorReason < ::Protobuf::Enum; end
+    
+    ##
+    # Message Classes
+    #
+    class Request < ::Protobuf::Message; end
+    class Response < ::Protobuf::Message; end
+    
+    ##
+    # Enum Values
+    #
+    ::Protobuf::Socketrpc::ErrorReason.define :BAD_REQUEST_DATA, 0
+    ::Protobuf::Socketrpc::ErrorReason.define :BAD_REQUEST_PROTO, 1
+    ::Protobuf::Socketrpc::ErrorReason.define :SERVICE_NOT_FOUND, 2
+    ::Protobuf::Socketrpc::ErrorReason.define :METHOD_NOT_FOUND, 3
+    ::Protobuf::Socketrpc::ErrorReason.define :RPC_ERROR, 4
+    ::Protobuf::Socketrpc::ErrorReason.define :RPC_FAILED, 5
+    ::Protobuf::Socketrpc::ErrorReason.define :INVALID_REQUEST_PROTO, 6
+    ::Protobuf::Socketrpc::ErrorReason.define :BAD_RESPONSE_PROTO, 7
+    ::Protobuf::Socketrpc::ErrorReason.define :UNKNOWN_HOST, 8
+    ::Protobuf::Socketrpc::ErrorReason.define :IO_ERROR, 9
+    
+    ##
+    # Message Fields
+    #
+    ::Protobuf::Socketrpc::Request.required(::Protobuf::Field::StringField, :service_name, 1)
+    ::Protobuf::Socketrpc::Request.required(::Protobuf::Field::StringField, :method_name, 2)
+    ::Protobuf::Socketrpc::Request.required(::Protobuf::Field::BytesField, :request_proto, 3)
+    
+    ::Protobuf::Socketrpc::Response.optional(::Protobuf::Field::BytesField, :response_proto, 1)
+    ::Protobuf::Socketrpc::Response.optional(::Protobuf::Field::StringField, :error, 2)
+    ::Protobuf::Socketrpc::Response.optional(::Protobuf::Field::BoolField, :callback, 3, :default => false)
+    ::Protobuf::Socketrpc::Response.optional(::Protobuf::Socketrpc::ErrorReason, :error_reason, 4)
+    
   end
-end
+end

data/lib/protobuf/rpc/server.rb

@@ -8,16 +8,6 @@ module Protobuf
   module Rpc
     module Server
 
-      def _gc_pause_request
-        return @_gc_pause_request unless @_gc_pause_request.nil?
-        @_gc_pause_request ||= (defined?(::Protobuf::Rpc::GC_PAUSE_REQUEST) && ::Protobuf::Rpc::GC_PAUSE_REQUEST)
-      end
-
-      def _gc_pause_serialization
-        return @_gc_pause_serialization unless @_gc_pause_serialization.nil?
-        @_gc_pause_serialization ||= (defined?(::Protobuf::Rpc::GC_PAUSE_SERIALIZATION) && ::Protobuf::Rpc::GC_PAUSE_SERIALIZATION)
-      end
-
       # Invoke the service method dictated by the proto wrapper request object
       def handle_client
         # Parse the protobuf request from the socket
@@ -30,7 +20,7 @@ module Protobuf
 
         # Call the service method
         log_debug { "[#{log_signature}] Dispatching client request to service" }
-        GC.disable if _gc_pause_request 
+        ::GC.disable if ::Protobuf.gc_pause_server_request
         invoke_rpc_method
       rescue => error
         # Ensure we're handling any errors that try to slip out the back door
@@ -108,11 +98,10 @@ module Protobuf
         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
-          # response types do not match, throw the appropriate error
+        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
@@ -122,8 +111,8 @@ module Protobuf
 
       # Parses and returns the service and method name from the request wrapper proto
       def parse_service_info
-        @klass = ::Protobuf::Util.constantize(@request.service_name)
-        @method = ::Protobuf::Util.underscore(@request.method_name).to_sym
+        @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"
@@ -144,17 +133,7 @@ module Protobuf
         @stats.log_stats
         @did_respond = true
       ensure
-        GC.enable if _gc_pause_request 
-      end
-
-      def serialize_response(response)
-        GC.disable if _gc_pause_serialization 
-        log_debug { "[#{log_signature}] serializing response: %s" % response.inspect }
-        @response.response_proto = response.serialize_to_string
-      rescue
-        raise BadResponseProto, $!.message
-      ensure
-        GC.enable if _gc_pause_serialization
+        ::GC.enable if ::Protobuf.gc_pause_server_request
       end
     end
   end

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

@@ -1,31 +1,31 @@
 module Protobuf
   module Rpc
-    class EventedRunner 
+    class EventedRunner
 
       def self.stop
-        EventMachine.stop_event_loop if EventMachine.reactor_running?
-        Protobuf::Logger.info 'Shutdown complete'
+        ::EventMachine.stop_event_loop if ::EventMachine.reactor_running?
       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
+        #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
-        EM.schedule do
-          EventMachine.start_server(server.host, server.port, Protobuf::Rpc::Evented::Server) && \
-            Protobuf::Logger.info('RPC Server listening at %s:%d in %s' % [server.host, server.port, server.env])
+        ::EventMachine.schedule do
+          ::EventMachine.start_server(server.host, server.port, ::Protobuf::Rpc::Evented::Server)
         end
 
         # Join or start the reactor
-        EM.reactor_running? ? EM.reactor_thread.join : EM.run
+				yield if block_given?
+        ::EM.reactor_running? ? ::EM.reactor_thread.join : ::EM.run
       end
     end
   end