protobuf 2.0.0.rc3 → 2.0.0.rc4

data/lib/protobuf/rpc/service_dispatcher.rb

@@ -0,0 +1,114 @@
+require 'protobuf/logger'
+
+module Protobuf
+  module Rpc
+    class ServiceDispatcher
+
+      include ::Protobuf::Logger::LogMethods
+
+      attr_accessor :service, :service_klass, :callable_method, :outer_request
+      attr_accessor :definition, :response, :error
+
+      def initialize(wrapper_request)
+        self.error = nil
+        self.outer_request = wrapper_request
+
+        init_service
+        init_method if service_klass.present?
+        register_rpc_failed if service.present?
+      end
+
+      # Call the given service method. If we get to this point and an error
+      # has already occurred, do not invoke the method and simply respond.
+      #
+      def invoke!
+        unless error?
+          callable_method.call
+          validate_response
+        end
+
+        return error || response
+      end
+
+      # We're successful if the error is not populated.
+      #
+      def success?
+        error.nil?
+      end
+
+      # We're in error if the error is populated.
+      #
+      def error?
+        ! success?
+      end
+
+      private
+
+      def assign_error(error_klass, message)
+        self.error = error_klass.new(message)
+      end
+
+      # Get the method for the current request.
+      #
+      def init_method
+        method_name = outer_request.method_name.underscore.to_sym
+        if service_klass.rpc_method?(method_name)
+          self.service = service_klass.new(method_name, outer_request.request_proto)
+          self.callable_method = service.method(method_name)
+          self.definition = service.rpcs[method_name]
+        else
+          assign_error(MethodNotFound, "#{service.class.name}##{method_name} is not a defined rpc method.")
+        end
+      rescue NameError => e
+        log_exception(e)
+        assign_error(MethodNotFound, "#{service.class.name}##{method_name} is not implemented.")
+      end
+
+      # Constantize the service for this request. Initialization of the service
+      # happens when we verify that the method is callable for this service.
+      #
+      def init_service
+        self.service_klass = outer_request.service_name.constantize
+      rescue NameError => e
+        log_exception(e)
+        assign_error(ServiceNotFound, "Service class #{outer_request.service_name} is not defined.")
+      end
+
+      # Make sure we get rpc errors back.
+      #
+      def register_rpc_failed
+        service.on_rpc_failed(method(:rpc_failed_callback))
+      end
+
+      # Receive the failure message from the service. This method is registered
+      # as the callable to the service when an `rpc_failed` call is invoked.
+      #
+      def rpc_failed_callback(message)
+        assign_error(RpcFailed, (message.respond_to?(:message) ? message.message : message))
+        log_error { sign_message("RPC Failed: #{error.message}") }
+      end
+
+      # Ensure that the response candidate we've been given is of the type
+      # we expect so that deserialization on the client side works.
+      #
+      def validate_response
+        expected = definition.response_type
+
+        candidate = service.response
+        candidate = expected.new(candidate) if candidate.is_a?(Hash)
+
+        actual = candidate.class
+        log_debug { sign_message("response (should/actual): #{expected.name}/#{actual.name}") }
+
+        # Determine if the service tried to change response types on us
+        if expected != actual
+          assign_error(BadResponseProto, "Response proto changed from #{expected.name} to #{actual.name}")
+        else
+          self.response = candidate
+        end
+      end
+
+    end
+  end
+end
+

data/lib/protobuf/rpc/stat.rb

@@ -1,69 +1,82 @@
 require 'date'
-require 'protobuf/common/logger'
+require 'protobuf/logger'
 
 module Protobuf
   module Rpc
     class Stat
-      attr_accessor :type, :start_time, :end_time, :request_size, :response_size, :client, :server, :service, :method
-      
-      TYPES = [:SERVER, :CLIENT]
-      
-      def initialize type=:SERVER, do_start=true
-        @type = type
-        start if do_start
+      attr_accessor :mode, :start_time, :end_time, :request_size, :dispatcher
+      attr_accessor :response_size, :client, :server, :service, :method
+
+      MODES = [:SERVER, :CLIENT].freeze
+
+      def initialize(mode = :SERVER)
+        @mode = mode
+        start
       end
-      
-      def client= peer
+
+      def client=(peer)
         @client = {:port => peer[0], :ip => peer[1]}
       end
-      
+
       def client
-        @client ? '%s:%d' % [@client[:ip], @client[:port]] : nil
+        @client ? "#{@client[:ip]}:#{@client[:port]}" : nil
+      end
+
+      def method
+        @method ||= @dispatcher.try(:callable_method).try(:name)
       end
-      
-      def server= peer
+
+      def server=(peer)
         @server = {:port => peer[0], :ip => peer[1]}
       end
-      
+
       def server
-        @server ? '%s:%d' % [@server[:ip], @server[:port]] : nil
+        @server ? "#{@server[:ip]}:#{@server[:port]}" : nil
+      end
+
+      def service
+        @service ||= @dispatcher.try(:service).class.name
       end
-      
+
       def sizes
-        '%dB/%dB' % [@request_size || 0, @response_size || 0]
+        "#{@request_size || 0}B/#{@response_size || 0}B"
       end
-      
+
       def start
         @start_time ||= Time.now
       end
-      
-      def end
+
+      def stop
         start if !@start_time
         @end_time ||= Time.now
       end
-      
+
       def rpc
-        service && method ? '%s#%s' % [service, method] : nil
+        service && method ? "#{service}##{method}" : nil
       end
-      
+
       def elapsed_time
-        (start_time && end_time ? '%ss' % (end_time - start_time).round(4) : nil)
+        (start_time && end_time ? "#{(end_time - start_time).round(4)}s" : nil)
       end
-      
-      def log_stats
-        Protobuf::Logger.info(self.to_s)
+
+      def server?
+        @mode == :SERVER
+      end
+
+      def client?
+        @mode == :CLIENT
       end
-      
+
       def to_s
         [
-          @type == :SERVER ? "[SRV-#{self.class}]" : "[CLT-#{self.class}]",
+          server? ? "[SRV-#{self.class}]" : "[CLT-#{self.class}]",
           rpc,
           elapsed_time,
           sizes,
-          @type == :SERVER ? server : client
-        ].delete_if{|v| v.nil? }.join(' - ')
+          server? ? server : client
+        ].compact.join(' - ')
       end
-      
+
     end
   end
 end

data/lib/protobuf/version.rb

@@ -1,4 +1,4 @@
 module Protobuf
-  VERSION = '2.0.0.rc3'
+  VERSION = '2.0.0.rc4'
   PROTOC_VERSION = '2.4.1'
 end

data/spec/benchmark/tasks.rb

@@ -4,7 +4,7 @@ require 'support/test/resource_service'
 require 'perftools'
 
 # Including a way to turn on debug logger for spec runs
-if ENV["DEBUG"] 
+if ENV["DEBUG"]
   puts 'debugging'
   debug_log = File.expand_path('../debug_bench.log', File.dirname(__FILE__) )
   Protobuf::Logger.configure(:file => debug_log, :level => ::Logger::DEBUG)
@@ -25,12 +25,12 @@ namespace :benchmark do
   def em_client_em_server(number_tests, test_length, global_bench = nil)
     EM.stop if EM.reactor_running?
 
-    EventMachine.fiber_run do 
+    EventMachine.fiber_run do
       StubServer.new do |server|
-        client = ::Test::ResourceService.client(:async => false)
+        client = ::Test::ResourceService.client
 
         benchmark_wrapper(global_bench) do |bench|
-          bench.report("ES / EC") do 
+          bench.report("ES / EC") do
             (1..number_tests.to_i).each { client.find(:name => "Test Name" * test_length.to_i, :active => true) }
           end
         end
@@ -44,11 +44,11 @@ namespace :benchmark do
     EM.stop if EM.reactor_running?
 
     EventMachine.fiber_run do
-      StubServer.new(:server => Protobuf::Rpc::Socket::Server, :port => 9399) do |server| 
-        client = ::Test::ResourceService.client(:async => false, :port => 9399)
+      StubServer.new(:server => Protobuf::Rpc::Socket::Server, :port => 9399) do |server|
+        client = ::Test::ResourceService.client(:port => 9399)
 
         benchmark_wrapper(global_bench) do |bench|
-          bench.report("SS / EC") do 
+          bench.report("SS / EC") do
             (1..number_tests.to_i).each { client.find(:name => "Test Name" * test_length.to_i, :active => true) }
           end
         end
@@ -63,11 +63,11 @@ namespace :benchmark do
     ::Protobuf::Rpc::Connector.connector_for_client(true)
     EM.stop if EM.reactor_running?
 
-    StubServer.new(:server => Protobuf::Rpc::Socket::Server, :port => 9399) do |server| 
-      client = ::Test::ResourceService.client(:async => false, :port => 9399)
+    StubServer.new(:server => Protobuf::Rpc::Socket::Server, :port => 9399) do |server|
+      client = ::Test::ResourceService.client(:port => 9399)
 
       benchmark_wrapper(global_bench) do |bench|
-        bench.report("SS / SC") do 
+        bench.report("SS / SC") do
           (1..number_tests.to_i).each { client.find(:name => "Test Name" * test_length.to_i, :active => true) }
         end
       end
@@ -81,11 +81,11 @@ namespace :benchmark do
     em_thread = Thread.new { EM.run }
     Thread.pass until EM.reactor_running?
 
-    StubServer.new(:port => 9399) do |server| 
-      client = ::Test::ResourceService.client(:async => false, :port => 9399)
+    StubServer.new(:port => 9399) do |server|
+      client = ::Test::ResourceService.client(:port => 9399)
 
       benchmark_wrapper(global_bench) do |bench|
-        bench.report("ES / SC") do 
+        bench.report("ES / SC") do
           (1..number_tests.to_i).each { client.find(:name => "Test Name" * test_length.to_i, :active => true) }
         end
       end
@@ -98,11 +98,11 @@ namespace :benchmark do
   def zmq_client_zmq_server(number_tests, test_length, global_bench = nil)
     load "protobuf/zmq.rb"
     ::Protobuf::Rpc::Connector.connector_for_client(true)
-    StubServer.new(:port => 9399, :server => Protobuf::Rpc::Zmq::Server) do |server| 
-      client = ::Test::ResourceService.client(:async => false, :port => 9399)
+    StubServer.new(:port => 9399, :server => Protobuf::Rpc::Zmq::Server) do |server|
+      client = ::Test::ResourceService.client(:port => 9399)
 
       benchmark_wrapper(global_bench) do |bench|
-        bench.report("ZS / ZC") do 
+        bench.report("ZS / ZC") do
           (1..number_tests.to_i).each { client.find(:name => "Test Name" * test_length.to_i, :active => true) }
         end
       end
@@ -119,7 +119,7 @@ namespace :benchmark do
   desc "benchmark ZMQ client with ZMQ server and profile"
   task :zmq_profile, [:number, :length, :profile_output] do |t, args|
     args.with_defaults(:number => 1000, :length => 100, :profile_output => "/tmp/zmq_profiler_#{Time.now.to_i}")
-    ::PerfTools::CpuProfiler.start(args[:profile_output]) do 
+    ::PerfTools::CpuProfiler.start(args[:profile_output]) do
       zmq_client_zmq_server(args[:number], args[:length])
     end
 
@@ -130,7 +130,7 @@ namespace :benchmark do
   task :profile_protobuf_new, [:number, :profile_output] do |t, args|
     args.with_defaults(:number => 1000, :profile_output => "/tmp/profiler_new_#{Time.now.to_i}")
     create_params = { :name => "The name that we set", :date_created => Time.now.to_i, :status => 2 }
-    ::PerfTools::CpuProfiler.start(args[:profile_output]) do 
+    ::PerfTools::CpuProfiler.start(args[:profile_output]) do
       args[:number].to_i.times { Test::Resource.new(create_params) }
     end
 

data/spec/functional/evented_server_spec.rb

@@ -5,14 +5,13 @@ describe 'Functional EventMachine Client' do
   before(:each) do
     load 'protobuf/evented.rb'
     ::Protobuf::Rpc::Connector.connector_for_client(true)
-    ::Test::ResourceService.configure(::Test::ResourceService::DEFAULT_LOCATION)
   end
 
   it 'runs fine when required fields are set' do
     expect {
       EventMachine.fiber_run do
         StubServer.new do |server|
-          client = ::Test::ResourceService.client(:async => false, :timeout => 5)
+          client = ::Test::ResourceService.client(:timeout => 5)
 
           client.find(:name => 'Test Name', :active => true) do |c|
             c.on_success do |succ|
@@ -35,7 +34,7 @@ describe 'Functional EventMachine Client' do
     EventMachine.fiber_run do
       StubServer.new do |server|
         request = ::Test::ResourceFindRequest.new(:active => true)
-        client = ::Test::ResourceService.client(:async => false)
+        client = ::Test::ResourceService.client
 
         client.find(request) do |c|
           c.on_success { raise "shouldn't pass"}
@@ -52,7 +51,7 @@ describe 'Functional EventMachine Client' do
     EventMachine.fiber_run do
       StubServer.new do |server|
         request = ::Test::Resource.new(:name => 'Test Name')
-        client = ::Test::ResourceService.client(:async => false)
+        client = ::Test::ResourceService.client
 
         client.find(request) do |c|
           c.on_success { raise "shouldn't pass"}

data/spec/functional/socket_server_spec.rb

@@ -18,7 +18,7 @@ describe 'Functional Socket Client' do
 
   it 'runs fine when required fields are set' do
     expect {
-      client = ::Test::ResourceService.client(:async => false)
+      client = ::Test::ResourceService.client
 
       client.find(:name => 'Test Name', :active => true) do |c|
         c.on_success do |succ|
@@ -36,7 +36,7 @@ describe 'Functional Socket Client' do
   it 'calls the on_failure callback when a message is malformed' do
     error = nil
     request = ::Test::ResourceFindRequest.new(:active => true)
-    client = ::Test::ResourceService.client(:async => false)
+    client = ::Test::ResourceService.client
 
     client.find(request) do |c|
       c.on_success { raise "shouldn't pass"}
@@ -48,7 +48,7 @@ describe 'Functional Socket Client' do
   it 'calls the on_failure callback when the request type is wrong' do
     error = nil
     request = ::Test::Resource.new(:name => 'Test Name')
-    client = ::Test::ResourceService.client(:async => false)
+    client = ::Test::ResourceService.client
 
     client.find(request) do |c|
       c.on_success { raise "shouldn't pass"}

data/spec/functional/zmq_server_spec.rb

@@ -18,7 +18,7 @@ describe 'Functional ZMQ Client' do
 
   it 'runs fine when required fields are set' do
     expect {
-      client = ::Test::ResourceService.client(:async => false)
+      client = ::Test::ResourceService.client
 
       client.find(:name => 'Test Name', :active => true) do |c|
         c.on_success do |succ|
@@ -36,7 +36,7 @@ describe 'Functional ZMQ Client' do
   it 'calls the on_failure callback when a message is malformed' do
     error = nil
     request = ::Test::ResourceFindRequest.new(:active => true)
-    client = ::Test::ResourceService.client(:async => false)
+    client = ::Test::ResourceService.client
 
     client.find(request) do |c|
       c.on_success { raise "shouldn't pass"}
@@ -48,7 +48,7 @@ describe 'Functional ZMQ Client' do
   it 'calls the on_failure callback when the request type is wrong' do
     error = nil
     request = ::Test::Resource.new(:name => 'Test Name')
-    client = ::Test::ResourceService.client(:async => false)
+    client = ::Test::ResourceService.client
 
     client.find(request) do |c|
       c.on_success { raise "shouldn't pass"}

data/spec/lib/protobuf/{common/logger_spec.rb → logger_spec.rb}

@@ -1,40 +1,40 @@
-require 'protobuf/common/logger'
+require 'protobuf/logger'
 require 'stringio'
 
 describe Protobuf::Logger do
-  
+
   subject { Protobuf::Logger }
-  
+
   before(:each) do
     Protobuf::Logger.reset_device!
     Protobuf::Logger.file = '/dev/null'
     Protobuf::Logger.level = ::Logger::INFO
   end
-  
+
   describe '.instance' do
-    
+
     it 'doesn\'t create a logger if the file was not set' do
       subject.file = nil
       subject.instance.should be_nil
     end
-    
+
     it 'doesn\'t create a logger if the level was not set' do
       subject.level = nil
       subject.instance.should be_nil
     end
-    
+
     it 'gets a new instance of the logger when file and level are set' do
       subject.file.should_not be_nil
       subject.level.should_not be_nil
       subject.instance.should_not be_nil
     end
-    
+
     it 'keeps the same object from multiple calls to instance' do
       subject.instance === subject.instance
     end
-    
+
   end
-  
+
   describe '.configure' do
     before(:each) { subject.reset_device! }
     it 'sets the file and level in one call' do
@@ -46,11 +46,11 @@ describe Protobuf::Logger do
       subject.level.should == ::Logger::WARN
       subject.instance.level.should == ::Logger::WARN
     end
-    
+
   end
-  
+
   describe '.reset_device!' do
-    
+
     it 'resets the logger instance, file, and level' do
       subject.instance.should be
       subject.file.should be
@@ -60,11 +60,11 @@ describe Protobuf::Logger do
       subject.file.should_not be
       subject.level.should_not be
     end
-    
+
   end
-  
+
   context 'when logging' do
-    
+
     it 'doesn\'t raise errors when log instance is nil' do
       subject.reset_device!
       subject.instance.should be_nil
@@ -78,44 +78,54 @@ describe Protobuf::Logger do
         subject.log 'No errors here'
       }.to_not raise_error
     end
-    
+
     it 'logs correctly when instance is valid' do
       subject.instance.should_not be_nil
       subject.instance.should_receive(:info).with('Should log great')
       subject.info 'Should log great'
     end
-    
+
   end
-  
+
   describe Protobuf::Logger::LogMethods do
-    
+
     context 'when included in another class' do
-      
+
       before(:all) do
         class MyTestClass
           include Protobuf::Logger::LogMethods
         end
       end
-      
+
       subject { MyTestClass.new }
-      
-      it 'responds to all logger methods' do
-        subject.should respond_to :log_debug
-        subject.should respond_to :log_info
-        subject.should respond_to :log_warn
-        subject.should respond_to :log_error
-        subject.should respond_to :log_fatal
-        subject.should respond_to :log_add
-        subject.should respond_to :log_log
+
+      it { should respond_to(:log_debug) }
+      it { should respond_to(:log_info) }
+      it { should respond_to(:log_warn) }
+      it { should respond_to(:log_error) }
+      it { should respond_to(:log_fatal) }
+      it { should respond_to(:log_add) }
+      it { should respond_to(:log_log) }
+
+      context '#log_exception' do
+        it 'logs the exception message as an error and backtrace as debug' do
+          subject.should_receive(:log_error).twice
+          subject.should_receive(:log_debug)
+          subject.log_exception(RuntimeError.new('this is an exception'))
+        end
       end
-      
+
+      its(:log_signature) { should eq "[MyTestClass]" }
+      describe '#sign_message' do
+        specify { subject.sign_message("this is a test").should eq "[MyTestClass] this is a test" }
+        specify { subject.class.sign_message("this is a test").should eq "[MyTestClass] this is a test" }
+      end
+
       it 'passes all embedded log calls to Logger instance' do
-        Protobuf::Logger.instance.should_receive(:debug).with('log this')
+        Protobuf::Logger.instance.should_receive(:debug).with('[MyTestClass] log this')
         subject.log_debug('log this')
       end
-      
+
     end
-    
   end
-  
 end