protobuf 1.0.0 → 1.0.1

data/lib/protobuf/rpc/connector.rb

@@ -0,0 +1,19 @@
+require 'protobuf/rpc/connectors/eventmachine'
+require 'protobuf/rpc/connectors/socket'
+
+module Protobuf
+  module Rpc
+    class Connector
+      
+      def self.connector_for_platform platform=RUBY_ENGINE
+        case platform
+        when /jruby/i
+          Connectors::Socket
+        else
+          Connectors::EventMachine
+        end
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'protobuf/common/logger'
+
+module Protobuf
+  module Rpc
+    module Connectors
+      class Base
+        include Protobuf::Logger::LogMethods
+        
+        attr_reader :options
+        attr_accessor :success_cb, :failure_cb
+        
+        def initialize options
+          @options = options
+          @success_cb = nil
+          @failure_cb = nil
+        end
+        
+        def send_request
+          raise 'not implemented'
+        end
+        
+        def async?
+          !!@options[:async]
+        end
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,227 @@
+require 'eventmachine'
+require 'protobuf/common/logger'
+require 'protobuf/rpc/rpc.pb'
+require 'protobuf/rpc/buffer'
+require 'protobuf/rpc/error'
+require 'protobuf/rpc/stat'
+
+# Handles client connections to the server
+module Protobuf
+  module Rpc
+    module Connectors
+      ClientError = Struct.new("ClientError", :code, :message)
+    
+      class EMClient < EM::Connection
+        include Protobuf::Logger::LogMethods
+      
+        attr_reader :options, :request, :response
+        attr_reader :error, :error_reason, :error_message
+
+        DEFAULT_OPTIONS = {
+          :service        => nil,           # Service to invoke
+          :method         => nil,           # Service method to call
+          :host           => 'localhost',   # A default host (usually overridden)
+          :port           => '9938',        # A default port (usually overridden)
+          :request        => nil,           # The request object sent by the client
+          :request_type   => nil,           # The request type expected by the client
+          :response_type  => nil,           # The response type expected by the client
+          :async          => false,         # Whether or not to block a client call, this is actually handled by client.rb
+          :timeout        => 30             # The default timeout for the request, also handled by client.rb
+        }
+      
+        # For state tracking
+        STATES = {
+          :pending    => 0,
+          :succeeded  => 1,
+          :failed     => 2,
+          :completed  => 3
+        }
+      
+        def self.connect options={}
+          options = DEFAULT_OPTIONS.merge(options)
+          Protobuf::Logger.debug '[client-cnxn] Connecting to server: %s' % options.inspect
+          host = options[:host]
+          port = options[:port]
+          EM.connect host, port, self, options
+        end
+      
+        def initialize options={}, &failure_cb
+          @failure_cb = failure_cb
+        
+          # Verify the options that are necessary and merge them in
+          [:service, :method, :host, :port].each do |opt|
+            fail(:RPC_ERROR, "Invalid client connection configuration. #{opt} must be a defined option.") if !options[opt] || options[opt].nil?
+          end
+          @options = DEFAULT_OPTIONS.merge(options)
+          log_debug '[client-cnxn] Client Initialized: %s' % options.inspect
+        
+          @error = ClientError.new
+          @success_cb = nil
+          @state = STATES[:pending]
+        
+          @stats = Protobuf::Rpc::Stat.new(:CLIENT, true)
+          @stats.server = [@options[:port], @options[:host]]
+          @stats.service = @options[:service].name
+          @stats.method = @options[:method]
+        rescue
+          fail(:RPC_ERROR, 'Failed to initialize connection: %s' % $!.message) unless failed?
+        end
+
+        # Success callback registration
+        def on_success &success_cb
+          @success_cb = success_cb
+        end
+      
+        # Failure callback registration
+        def on_failure &failure_cb
+          @failure_cb = failure_cb
+        end
+      
+        # Completion callback registration
+        def on_complete &complete_cb
+          @complete_cb = complete_cb
+        end
+      
+        # Called after the EM.connect
+        def connection_completed
+          log_debug '[client-cnxn] Established server connection, sending request'
+          send_request unless error?
+        rescue
+          fail(:RPC_ERROR, 'Connection error: %s' % $!.message) unless failed?
+        end
+      
+        # Setup the read buffer for data coming back
+        def post_init
+          log_debug '[client-cnxn] Post init, new read buffer created'
+          @buffer = Protobuf::Rpc::Buffer.new :read
+        rescue
+          fail(:RPC_ERROR, 'Connection error: %s' % $!.message) unless failed?
+        end
+      
+        def receive_data data
+          log_debug '[client-cnxn] receive_data: %s' % data
+          @buffer << data
+          parse_response if @buffer.flushed?
+        end
+    
+        def pending?
+          @state == STATES[:pending]
+        end
+    
+        def succeeded?
+          @state == STATES[:succeeded]
+        end
+    
+        def failed?
+          @state == STATES[:failed]
+        end
+    
+        def completed?
+          @state == STATES[:completed]
+        end
+      
+      private
+    
+        # 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
+        
+          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
+        
+          log_debug '[client-cnxn] Sending Request: %s' % request_wrapper.inspect
+          request_buffer = Protobuf::Rpc::Buffer.new(:write, request_wrapper)
+          send_data(request_buffer.write)
+          @stats.request_size = request_buffer.size
+        end
+      
+        def parse_response
+          # Close up the connection as we no longer need it
+          close_connection
+        
+          log_debug '[client-cnxn] Parsing response from server (connection closed)'
+          @stats.response_size = @buffer.size
+        
+          # Parse out the raw response
+          response_wrapper = Protobuf::Socketrpc::Response.new
+          response_wrapper.parse_from_string @buffer.data
+        
+          # Determine success or failure based on parsed data
+          if response_wrapper.has_field? :error_reason
+            log_debug '[client-cnxn] 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 '[client-cnxn] Successful response parsed'
+          
+            # Ensure client_response is an instance
+            response_type = @options[:response_type].new
+            parsed = response_type.parse_from_string(response_wrapper.response_proto.to_s)
+      
+            if parsed.nil? and not response_wrapper.has_field?(:error_reason)
+              fail :BAD_RESPONSE_PROTO, 'Unable to parse response from server'
+            else
+              succeed parsed
+            end
+          end
+        end
+      
+        def fail code, message
+          @state = STATES[:failed]
+          @error.code = code.is_a?(Symbol) ? Protobuf::Socketrpc::ErrorReason.values[code] : code
+          @error.message = message
+          log_debug '[client-cnxn] Server failed request (invoking on_failure): %s' % @error.inspect
+          begin
+            @stats.end
+            @stats.log_stats
+            @failure_cb.call(@error) unless @failure_cb.nil?
+          rescue
+            log_error '[client-cnxn] Failure callback error encountered: %s' % $!.message
+            log_error '[client-cnxn] %s' % $!.backtrace.join("\n")
+            raise
+          ensure
+            complete
+          end
+        end
+      
+        def succeed response
+          @state = STATES[:succeeded]
+          begin
+            log_debug '[client-cnxn] Server succeeded request (invoking on_success)'
+            @stats.end
+            @stats.log_stats
+            @success_cb.call(response) unless @success_cb.nil?
+            complete
+          rescue
+            log_error '[client-cnxn] Success callback error encountered: %s' % $!.message
+            log_error '[client-cnxn] %s' % $!.backtrace.join("\n")
+            fail :RPC_ERROR, 'An exception occurred while calling on_success: %s' % $!.message
+          end
+        end
+      
+        def complete
+          @state = STATES[:completed]
+          begin
+            log_debug '[client-cnxn] Response proceessing complete'
+            @success_cb = @failure_cb = nil
+            @complete_cb.call(@state) unless @complete_cb.nil?
+          rescue
+            log_error '[client-cnxn] Complete callback error encountered: %s' % $!.message
+            log_error '[client-cnxn] %s' % $!.backtrace.join("\n")
+            raise
+          end
+        end
+  
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+require 'protobuf/rpc/connectors/base'
+require 'protobuf/rpc/connectors/em_client'
+
+module Protobuf
+  module Rpc
+    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?
+
+          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'
+          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
+        # 
+        # 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
+        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)
+        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 ex.message
+          log_error ex.backtrace.join("\n")
+
+          message = 'Synchronous client failed: %s' % ex.message
+          err = ClientError.new(Protobuf::Socketrpc::ErrorReason::RPC_ERROR, message)
+          ensure_cb.call(err)
+        end
+
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'protobuf/rpc/connectors/base'
+
+module Protobuf
+  module Rpc
+    module Connectors
+      class Socket < Base
+        
+        def send_request
+        end
+        
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/service.rb

@@ -141,8 +141,8 @@ module Protobuf
       
       # Callback register for the server when a service
       # method calls rpc_failed. Called by Service#rpc_failed.
-      def on_rpc_failed &rpc_failure_callback
-        @rpc_failure_callback = rpc_failure_callback
+      def on_rpc_failed &rpc_failure_cb
+        @rpc_failure_cb = rpc_failure_cb
       end
       
       # Automatically fail a service method.
@@ -150,14 +150,14 @@ module Protobuf
       # 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}"
-        if @rpc_failure_callback.nil?
+        if @rpc_failure_cb.nil?
           exc = RuntimeError.new 'Unable to invoke rpc_failed, no failure callback is setup.' 
           log_error exc.message
           raise exc
         end
         error = message.is_a?(String) ? RpcFailed.new(message) : message
         log_warn '[service] RPC Failed: %s' % error.message
-        @rpc_failure_callback.call(error)
+        @rpc_failure_cb.call(error)
       end
       
       # Callback register for the server to be notified

data/lib/protobuf/version.rb

@@ -1,3 +1,3 @@
 module Protobuf
-  VERSION = '1.0.0'
+  VERSION = '1.0.1'
 end

data/protobuf.gemspec

@@ -5,10 +5,10 @@ require "protobuf/version"
 Gem::Specification.new do |s|
   s.name          = 'protobuf'
   s.version       = Protobuf::VERSION
-  s.date          = %q{2011-11-06}
+  s.date          = %q{2011-12-07}
 
-  s.authors       = ['BJ Neilsen']
-  s.email         = ["bj.neilsen@gmail.com"]
+  s.authors       = ['BJ Neilsen', 'Brandon Dewitt']
+  s.email         = ["bj.neilsen@gmail.com", "brandonsdewitt@gmail.com"]
   s.homepage      = %q{https://github.com/localshred/protobuf}
   s.summary       = 'Ruby implementation for Protocol Buffers. Works with other protobuf rpc implementations (e.g. Java, Python, C++).'
   s.description   = s.summary + "\n\nThis gem has diverged from https://github.com/macks/ruby-protobuf. All credit for serialization and rprotoc work most certainly goes to the original authors. All RPC implementation code (client/server/service) was written and is maintained by this author. Attempts to reconcile the original codebase with the current RPC implementation went unsuccessful."

data/spec/helper/all.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'rspec'
+
+require 'helper/tolerance_matcher'
+require 'helper/server'
+
+def now
+  Time.new.to_f
+end
+
+RSpec.configure do |con|
+  con.include(Sander6::CustomMatchers)
+end

data/spec/helper/server.rb

@@ -0,0 +1,36 @@
+require 'lib/protobuf/rpc/server'
+require 'spec/proto/test_service_impl'
+
+module StubProtobufServerFactory
+  def self.build(delay)
+    new_server = Class.new(Protobuf::Rpc::Server) do
+      class << self
+        def sleep_interval
+          @sleep_interval
+        end
+
+        def sleep_interval=(si)
+          @sleep_interval = si
+        end
+      end
+
+      def post_init
+        sleep self.class.sleep_interval
+        super
+      end
+    end
+
+    new_server.sleep_interval = delay
+    return new_server
+  end
+end
+
+class StubServer
+  def initialize(delay = 0, port = 9191)
+    @server_handle = EventMachine::start_server("127.0.0.1", port, StubProtobufServerFactory.build(delay)) 
+  end
+
+  def stop
+    EventMachine.stop_server(@server_handle)
+  end
+end