protobuf 2.0.0.rc3 → 2.0.0.rc4

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

@@ -1,3 +1,6 @@
+require 'protobuf/rpc/server'
+require 'protobuf/logger'
+
 module Protobuf
   module Rpc
     module Socket
@@ -7,34 +10,26 @@ module Protobuf
         include ::Protobuf::Logger::LogMethods
 
         def initialize(sock, &complete_cb)
-          @did_response = false
           @socket = sock
-          @request = Protobuf::Socketrpc::Request.new
-          @response = Protobuf::Socketrpc::Response.new
+          initialize_request!
+
           request_buffer = Protobuf::Rpc::Buffer.new(:read)
-          @stats = Protobuf::Rpc::Stat.new(:SERVER, true)
           @complete_cb = complete_cb
-          log_debug { "[#{log_signature}] Post init, new read buffer created" }
 
-          @stats.client = ::Socket.unpack_sockaddr_in(@socket.getpeername)
-          log_debug { "stats are #{@stats.to_s}" }
+          log_debug { sign_message("stats are #{@stats.to_s}") }
           request_buffer << read_data
           @request_data = request_buffer.data
 
           @stats.request_size = request_buffer.size
 
-          log_debug { "[#{log_signature}] handling request" }
+          log_debug { sign_message("handling request") }
           handle_client if request_buffer.flushed?
         end
 
-        def log_signature
-          @log_signature ||= "server-#{self.class}-#{object_id}"
-        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
@@ -43,15 +38,27 @@ module Protobuf
         end
 
         def send_data
-          raise 'Socket closed unexpectedly' if(@socket.nil? || @socket.closed?)
+          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 { "[#{log_signature}] sending data : %s" % response_buffer.data }
+          log_debug { sign_message("sending data : #{response_buffer.data}") }
           @socket.write(response_buffer.write)
           @socket.flush
           @complete_cb.call(@socket)
         end
+
+        def log_signature
+          @_log_signature ||= "server-#{self.class}-#{object_id}"
+        end
+
+        def set_peer
+          @stats.client = ::Socket.unpack_sockaddr_in(@socket.getpeername)
+        end
+
+        def socket_writable?
+          ! @socket.nil? && ! @socket.closed?
+        end
       end
 
     end

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

@@ -12,18 +12,18 @@ module Protobuf
         # Class Methods
         #
         def self.run(opts = {})
-          log_debug { "[#{log_signature}] initializing broker" }
+          log_debug { sign_message("initializing broker") }
           @broker = ::Protobuf::Rpc::Zmq::Broker.new(opts)
           local_worker_threads = opts.fetch(:threads, 5)
 
           worker_options = opts.merge(:port => opts.fetch(:port, 9399) + 1)
-          log_debug { "[#{log_signature}] starting server workers" }
+          log_debug { sign_message("starting server workers") }
           local_worker_threads.times do
             @threads << Thread.new { ::Protobuf::Rpc::Zmq::Worker.new(worker_options).run }
           end
           @running = true
 
-          log_debug { "[#{log_signature}] server started" }
+          log_debug { sign_message("server started") }
           while self.running? do
             @broker.poll
           end

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

@@ -13,7 +13,7 @@ module Protobuf
         end
 
         def log_signature
-          @log_signature ||= "server-#{self.class}-#{object_id}"
+          @_log_signature ||= "server-#{self.class}-#{object_id}"
         end
 
         def resolve_ip(hostname)

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

@@ -13,9 +13,9 @@ module Protobuf
         #
         def initialize(opts={})
           @options = opts
-          host = @options.fetch(:host, "127.0.0.1")
-          port = @options.fetch(:port, 9400)
-          protocol = @options.fetch(:protocol, "tcp")
+          host = @options.fetch(:host) { "127.0.0.1" }
+          port = @options.fetch(:port) { 9400 }
+          protocol = @options.fetch(:protocol) { "tcp" }
 
           @zmq_context = ::ZMQ::Context.new
           @socket = @zmq_context.socket(::ZMQ::REP)
@@ -31,15 +31,7 @@ module Protobuf
         def handle_request(socket)
           @request_data = ''
           zmq_error_check(socket.recv_string(@request_data))
-          log_debug { "[#{log_signature}] handling request" } if(!@request_data.nil?)
-        end
-
-        def initialize_buffers
-          @did_respond = false
-          @request = ::Protobuf::Socketrpc::Request.new
-          @response = ::Protobuf::Socketrpc::Response.new
-          @stats = ::Protobuf::Rpc::Stat.new(:SERVER, true)
-          log_debug { "[#{log_signature}] Post init" }
+          log_debug { sign_message("handling request") } if !@request_data.nil?
         end
 
         def run
@@ -48,9 +40,9 @@ module Protobuf
             # This lets us see whether we need to die
             @poller.poll(1_000)
             @poller.readables.each do |socket|
-              initialize_buffers
+              initialize_request!
               handle_request(socket)
-              handle_client unless(@request_data.nil?)
+              handle_client unless @request_data.nil?
             end
           end
         ensure
@@ -62,7 +54,6 @@ module Protobuf
           response_data = @response.is_a?(::Protobuf::Message) ? @response.serialize_to_string : @response.to_s
           @stats.response_size = response_data.size
           zmq_error_check(@socket.send_string(response_data))
-          @did_respond = true
         end
       end
 

data/lib/protobuf/rpc/service.rb

@@ -1,243 +1,160 @@
-require 'protobuf/common/logger'
+require 'protobuf/logger'
 require 'protobuf/rpc/client'
 require 'protobuf/rpc/error'
 
 module Protobuf
   module Rpc
     # Object to encapsulate the request/response types for a given service method
-    # 
-    RpcMethod = Struct.new("RpcMethod", :service, :method, :request_type, :response_type)
-    
+    #
+    RpcMethod = Struct.new("RpcMethod", :method, :request_type, :response_type)
+
     class Service
       include Protobuf::Logger::LogMethods
-    
-      attr_reader :request
-      attr_accessor :response, :async_responder
-      private :request, :response, :response=
-      
-      DEFAULT_LOCATION = {
-        :host => '127.0.0.1',
-        :port => 9399 
-      }
-      
-      # Class methods are intended for use on the client-side.
-      #
-      class << self
-        
-        # You MUST add the method name to this list if you are adding
-        # instance methods below, otherwise stuff will definitely break
-        NON_RPC_METHODS = %w( rpcs call_rpc on_rpc_failed rpc_failed request response method_missing async_responder on_send_response send_response log_signature )
-        
-        # Override methods being added to the class
-        # If the method isn't already a private instance method, or it doesn't start with rpc_, 
-        # or it isn't in the reserved method list (NON_RPC_METHODS),
-        # We want to remap the method such that we can wrap it in before and after behavior,
-        # most notably calling call_rpc against the method. See call_rpc for more info.
-        def method_added(old)
-          new_method = :"rpc_#{old}"
-          return if private_instance_methods.include?(new_method) or old =~ /^rpc_/ or NON_RPC_METHODS.include?(old.to_s)
-          
-          alias_method new_method, old
-          private new_method
-          
-          define_method(old) do |pb_request|
-            call_rpc(old.to_sym, pb_request)
-          end
-        rescue ArgumentError => e
-          # Wrap a known issue where an instance method was defined in the class without
-          # it being ignored with NON_RPC_METHODS. 
-          raise ArgumentError, "#{e.message} (Note: This could mean that you need to add the method #{old} to the NON_RPC_METHODS list)"
-        end
-      
-        # Generated service classes should call this method on themselves to add rpc methods
-        # to the stack with a given request and response type
-        def rpc(method, request_type, response_type)
-          rpcs[self] ||= {}
-          rpcs[self][method] = RpcMethod.new self, method, request_type, response_type
-        end
-
-        # Shorthand for @rpcs class instance var
-        def rpcs
-          @rpcs ||= {}
-        end
-        
-        # Create a new client for the given service.
-        # See Client#initialize and ClientConnection::DEFAULT_OPTIONS
-        # for all available options.
-        #
-        def client(options={})
-          configure
-          Client.new({
-            :service => self,
-            :async => false,
-            :host => self.host,
-            :port => self.port
-          }.merge(options))
-        end
-        
-        # Allows service-level configuration of location.
-        # Useful for system-startup configuration of a service
-        # so that any Clients using the Service.client sugar
-        # will not have to configure the location each time.
-        # 
-        def configure(config={})
-          locations[self] ||= {}
-          locations[self][:host] = config[:host] if config.key?(:host)
-          locations[self][:port] = config[:port] if config.key?(:port)
-        end
-        
-        # Shorthand call to configure, passing a string formatted as hostname:port
-        # e.g. 127.0.0.1:9933
-        # e.g. localhost:0
-        #
-        def located_at(location)
-          return if location.nil? or location.downcase.strip !~ /[a-z0-9.]+:\d+/
-          host, port = location.downcase.strip.split ':'
-          configure :host => host, :port => port.to_i
-        end
-        
-        # The host location of the service
-        def host
-          configure
-          locations[self][:host] || DEFAULT_LOCATION[:host]
-        end
-        
-        # The port of the service on the destination server
-        def port
-          configure
-          locations[self][:port] || DEFAULT_LOCATION[:port]
-        end
-      
-        # Shorthand for @locations class instance var
-        def locations
-          @locations ||= {}
-        end
-        
-      end
-
-      def log_signature
-        @log_signature ||= "service-#{self.class}"
-      end
-      
-      # If a method comes through that hasn't been found, and it
-      # is defined in the rpcs method list, we know that the rpc
-      # stub has been created, but no implementing method provides the
-      # functionality, so throw an appropriate error, otherwise go to super
-      # 
-      def method_missing m, *params
-        if rpcs.key?(m)
-          exc = MethodNotFound.new "#{self}##{m} was defined as a valid rpc method, but was not implemented."
-          log_error exc.message
-          raise exc
-        else
-          log_error { "-------------- [#{log_signature}] %s#%s not rpc method, passing to super" % [self.class.name, m.to_s] }
-          super m, params
-        end
-      end
-
-      # Convenience wrapper around the rpc method list for a given class
+
+      attr_reader :response
+
+      DEFAULT_HOST = '127.0.0.1'.freeze
+      DEFAULT_PORT = 9399
+
+      ##
+      # Class Methods
+      #
+
+      # Create a new client for the given service.
+      # See Client#initialize and ClientConnection::DEFAULT_OPTIONS
+      # for all available options.
+      #
+      def self.client(options = {})
+        ::Protobuf::Rpc::Client.new({ :service => self,
+                                      :host => host,
+                                      :port => port }.merge(options))
+      end
+
+      # Allows service-level configuration of location.
+      # Useful for system-startup configuration of a service
+      # so that any Clients using the Service.client sugar
+      # will not have to configure the location each time.
+      #
+      def self.configure(config = {})
+        self.host = config[:host] if config.key?(:host)
+        self.port = config[:port] if config.key?(:port)
+      end
+
+      # The host location of the service.
+      #
+      def self.host
+        @_host ||= DEFAULT_HOST
+      end
+
+      # The host location setter.
+      #
+      def self.host=(new_host)
+        @_host = new_host
+      end
+
+      # Shorthand call to configure, passing a string formatted as hostname:port
+      # e.g. 127.0.0.1:9933
+      # e.g. localhost:0
+      #
+      def self.located_at(location)
+        return if location.nil? || location.downcase.strip !~ /.+:\d+/
+        host, port = location.downcase.strip.split ':'
+        configure(:host => host, :port => port.to_i)
+      end
+
+      # The port of the service on the destination server.
+      #
+      def self.port
+        @_port ||= DEFAULT_PORT
+      end
+
+      # The port location setter.
+      #
+      def self.port=(new_port)
+        @_port = new_port
+      end
+
+      # Define an rpc method with the given request and response types.
+      # This methods is only used by the generated service definitions
+      # and not useful for user code.
+      #
+      def self.rpc(method, request_type, response_type)
+        rpcs[method] = RpcMethod.new(method, request_type, response_type)
+      end
+
+      # Hash containing the set of methods defined via `rpc`.
+      #
+      def self.rpcs
+        @_rpcs ||= {}
+      end
+
+      # Check if the given method name is a known rpc endpoint.
+      #
+      def self.rpc_method?(name)
+        rpcs.key?(name)
+      end
+
+
+      ##
+      # Instance Methods
+      #
+
+      # Initialize a service with the rpc endpoint name and the bytes
+      # for the request.
+      def initialize(rpc, request_bytes)
+        @rpc = rpc
+        @request_bytes = request_bytes
+      end
+
+      # Register a failure callback for use when rpc_failed is invoked.
+      #
+      def on_rpc_failed(callable)
+        @rpc_failed_callback ||= callable
+      end
+
+      # Response object for this rpc cycle. Not assignable.
+      #
+      def response
+        @_response ||= rpcs[@rpc].response_type.new
+      end
+
+      # Convenience method to get back to class method.
+      #
+      def rpc_method?(name)
+        self.class.rpc_method?(name)
+      end
+
+      # Convenience method to get back to class rpcs hash.
+      #
       def rpcs
-        self.class.rpcs[self.class]
+        self.class.rpcs
       end
-      
-      # Callback register for the server when a service
-      # method calls rpc_failed. Called by Service#rpc_failed.
-      def on_rpc_failed(&rpc_failure_cb)
-        @rpc_failure_cb = rpc_failure_cb
+
+      private
+
+      # Request object for this rpc cycle. Not assignable.
+      #
+      def request
+        @_request ||= rpcs[@rpc].request_type.new.parse_from_string(@request_bytes)
+      rescue => e
+        raise BadRequestProto, "Unable to parse request: #{e.message}"
       end
-      
+
+      # Sugar to make an rpc method feel like a controller method.
+      # If this method is not called, the response will be the memoized
+      # object returned by the response reader.
+      #
+      def respond_with(candidate)
+        @_response = candidate
+      end
+      alias_method :return_from_whence_you_came, :respond_with
+
       # Automatically fail a service method.
-      # NOTE: This shortcuts the @async_responder paradigm. There is
-      # not any way to get around this currently (and I'm not sure you should want to).
-      #
-      def rpc_failed(message="RPC Failed while executing service method #{@current_method}")
-        error_message = 'Unable to invoke rpc_failed, no failure callback is setup.' 
-        log_and_raise_error(error_message) if @rpc_failure_cb.nil?
-        error = message.is_a?(String) ? RpcFailed.new(message) : message
-        log_warn "[#{log_signature}] RPC Failed: %s" % error.message
-        @rpc_failure_cb.call(error)
-      end
-      
-      # Callback register for the server to be notified
-      # when it is appropriate to generate a response to the client.
-      # Used in conjunciton with Service#send_response.
-      # 
-      def on_send_response(&responder)
-        @responder = responder
-      end
-      
-      # Tell the server to generate response and send it to the client.
-      #
-      # NOTE: If @async_responder is set to true, this MUST be called by
-      # the implementing service method, otherwise the connection
-      # will timeout since no data will be sent.
-      #
-      def send_response
-        error_message = "Unable to send response, responder is nil. It appears you aren't inside of an RPC request/response cycle."
-        log_and_raise_error(error_message) if @responder.nil?
-        @responder.call(@response)
-      end
-  
-    private
-
-      def log_and_raise_error(error_message)
-        log_error(error_message)
-        raise error_message
-      end
-      
-      # Call the rpc method that was previously privatized.
-      # call_rpc allows us to wrap the normal method call with 
-      # before and after behavior, most notably setting up the request
-      # and response instances.
-      # 
-      # Implementing rpc methods should be aware
-      # that request and response are implicitly available, and
-      # that response should be manipulated during the rpc method,
-      # as there is no way to reliably determine the response like
-      # a normal (http-based) controller method would be able to.
-      #
-      # Async behavior of responding can be achieved in the rpc method
-      # by explicitly setting self.async_responder = true. It is then
-      # the responsibility of the service method to send the response,
-      # by calling self.send_response without any arguments. The rpc
-      # server is setup to handle synchronous and asynchronous responses.
-      #
-      def call_rpc(method, pb_request)
-        @current_method = method
-        
-        # Allows the service to set whether or not
-        # it would like to asynchronously respond to the connected client(s)
-        @async_responder = false
-        
-        # Setup the request
-        @request = rpcs[method].request_type.new
-        @request.parse_from_string(pb_request.request_proto)
-      rescue
-        exc = BadRequestProto.new 'Unable to parse request: %s' % $!.message
-        log_error exc.message
-        log_error $!.backtrace.join("\n")
-        raise exc
-      else   # when no Exception was thrown
-        # Setup the response
-        @response = rpcs[method].response_type.new
-
-        log_debug { "[#{log_signature}] calling service method %s#%s" % [self.class, method] }
-        # Call the aliased rpc method (e.g. :rpc_find for :find)
-        __send__("rpc_#{method}".to_sym)
-        log_debug { "[#{log_signature}] completed service method %s#%s" % [self.class, method] }
-        
-        # Pass the populated response back to the server
-        # Note this will only get called if the rpc method didn't explode (by design)
-        if @async_responder
-          log_debug { "[#{log_signature}] async request, not sending response (yet)" }
-        else
-          log_debug { "[#{log_signature}] trigger server send_response" }
-          send_response
-        end
-      end
-      
+      #
+      def rpc_failed(message)
+        @rpc_failed_callback.call(message)
+      end
+
     end
-    
   end
-
 end