protobuf 2.2.5-java

data/lib/protobuf/rpc/connector.rb

@@ -0,0 +1,19 @@
+module Protobuf
+  module Rpc
+    class Connector
+
+      # Returns a connector class for the pre-defined connector_type.
+      def self.connector_for_client
+        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
+
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'protobuf/logger'
+require 'protobuf/rpc/rpc.pb'
+require 'protobuf/rpc/buffer'
+require 'protobuf/rpc/error'
+require 'protobuf/rpc/stat'
+require 'protobuf/rpc/connectors/common'
+
+module Protobuf
+  module Rpc
+    module Connectors
+      DEFAULT_OPTIONS = {
+        :service        => nil,           # Service to invoke
+        :method         => nil,           # Service method to call
+        :host           => '127.0.0.1',   # A default host (usually overridden)
+        :port           => '9399',        # 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
+        :timeout        => 30             # The default timeout for the request, also handled by client.rb
+      }
+
+      class Base
+        include Protobuf::Logger::LogMethods
+
+        attr_reader :options
+        attr_accessor :success_cb, :failure_cb, :complete_cb
+
+        def initialize(options)
+          @options = DEFAULT_OPTIONS.merge(options)
+        end
+
+        def send_request
+          raise 'If you inherit a Connector from Base you must implement send_request'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,156 @@
+module Protobuf
+  module Rpc
+    module Connectors
+      module Common
+
+        attr_reader :error
+
+        def any_callbacks?
+          return [@complete_cb, @failure_cb, @success_cb].inject(false) do |reduction, cb|
+            reduction = (reduction || !cb.nil?)
+          end
+        end
+
+        def complete
+          @stats.stop
+          log_info { @stats.to_s }
+          log_debug { sign_message('Response proceessing complete') }
+          @complete_cb.call(self) unless @complete_cb.nil?
+        rescue => e
+          log_error { sign_message('Complete callback error encountered') }
+          log_exception(e)
+          raise
+        end
+
+        def data_callback(data)
+          log_debug { sign_message('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 { sign_message("Server failed request (invoking on_failure): #{@error.inspect}") }
+
+          @failure_cb.call(@error) unless @failure_cb.nil?
+        rescue => e
+          log_error { sign_message("Failure callback error encountered") }
+          log_exception(e)
+          raise
+        ensure
+          complete
+        end
+
+        def initialize_stats
+          @stats = Protobuf::Rpc::Stat.new(:CLIENT)
+          @stats.server = [@options[:port], @options[:host]]
+          @stats.service = @options[:service].name
+          @stats.method_name = @options[:method].to_s
+        rescue => ex
+          log_exception(ex)
+          fail(:RPC_ERROR, "Invalid stats configuration. #{ex.message}")
+        end
+
+        def log_signature
+          @_log_signature ||= "client-#{self.class}"
+        end
+
+        def parse_response
+          # Close up the connection as we no longer need it
+          close_connection
+
+          log_debug { sign_message("Parsing response from server (connection closed)") }
+
+          # Parse out the raw response
+          response_wrapper = Protobuf::Socketrpc::Response.new
+          response_wrapper.parse_from_string(@response_data)
+
+          # Determine success or failure based on parsed data
+          if response_wrapper.has_field?(:error_reason)
+            log_debug { sign_message("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 { sign_message("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
+              verify_callbacks
+              succeed(parsed)
+              return @data if @used_data_callback
+            end
+          end
+        end
+
+        def post_init
+          send_data unless error?
+        rescue => e
+          fail(:RPC_ERROR, "Connection error: #{e.message}")
+        end
+
+        def rpc_request_data
+          validate_request_type
+
+          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 => e
+          fail(:INVALID_REQUEST_PROTO, "Could not set request proto: #{e.message}")
+        end
+
+        def setup_connection
+          initialize_stats
+          @request_data = rpc_request_data
+        end
+
+        def succeed(response)
+          log_debug { sign_message("Server succeeded request (invoking on_success)") }
+          @success_cb.call(response) unless @success_cb.nil?
+        rescue => e
+          log_error { sign_message("Success callback error encountered") }
+          log_exception(e)
+          fail(:RPC_ERROR, "An exception occurred while calling on_success: #{e.message}")
+        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 #{expected}, got #{actual} instead")
+          end
+        end
+
+        def verify_callbacks
+          if !any_callbacks?
+            log_debug { sign_message("No callbacks set, using data_callback") }
+            @success_cb = @failure_cb = self.method(:data_callback)
+          end
+        end
+
+        def verify_options
+          # 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].nil?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# Handles client connections to the server
+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
+
+        ##
+        # Constructor
+        #
+        def initialize(options = {}, &failure_cb)
+          @failure_cb = failure_cb
+          @options = DEFAULT_OPTIONS.merge(options)
+          @response_buffer = ::Protobuf::Rpc::Buffer.new(:read)
+          verify_options
+
+          log_debug { sign_message("Client Initialized: #{options.inspect}") }
+        rescue => e
+          fail(:RPC_ERROR, "Failed to initialize connection: #{e.message}")
+        end
+
+        ##
+        # Class Methods
+        #
+        def self.connect(options = {})
+          options = DEFAULT_OPTIONS.merge(options)
+          log_debug { sign_message("Connecting to server: #{options.inspect}") }
+          EM.connect(options[:host], options[:port], self, options)
+        end
+
+        # 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 { sign_message("receive_data: #{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 { sign_message("sending data: #{request_buffer.inspect}") }
+          super(request_buffer.write)
+        rescue => e
+          fail(:RPC_ERROR, "Connection error: #{e.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
+end

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

@@ -0,0 +1,87 @@
+require 'protobuf/rpc/connectors/base'
+require 'protobuf/rpc/connectors/em_client'
+
+module Protobuf
+  module Rpc
+    module Connectors
+      class EventMachine < Base
+
+        def send_request
+          ensure_em_running do
+            f = Fiber.current
+
+            ::EM.next_tick do
+              log_debug { sign_message('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) }
+              cnxn.setup_connection
+              cnxn.send_data
+              log_debug { sign_message('Connection scheduled') }
+            end
+
+            set_timeout_and_validate_fiber
+          end
+        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 "#{error.code.name}: #{error.message}" })
+        end
+
+        def log_signature
+          @_log_signature ||= "client-#{self.class}"
+        end
+
+        private
+
+        def ensure_em_running(&blk)
+          if ::EM.reactor_running?
+            @using_global_reactor = true
+            yield
+          else
+            @using_global_reactor = false
+            ::EM.fiber_run do
+              blk.call
+              ::EM.stop
+            end
+          end
+        end
+
+        def resume_fiber(fib)
+          ::EM::cancel_timer(@timeout_timer)
+          fib.resume(true)
+        rescue => ex
+          log_exception(ex)
+          message = "Synchronous client failed: #{ex.message}"
+          error_stop_reactor(message)
+        end
+
+        def set_timeout_and_validate_fiber
+          @timeout_timer = ::EM::add_timer(@options[:timeout]) do
+            message = "Client timeout of #{@options[:timeout]} seconds expired"
+            error_stop_reactor(message)
+          end
+
+          Fiber.yield
+        rescue FiberError => ex
+          log_exception(ex)
+          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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+require 'protobuf/rpc/connectors/base'
+
+module Protobuf
+  module Rpc
+    module Connectors
+      class Socket < Base
+        include Protobuf::Rpc::Connectors::Common
+        include Protobuf::Logger::LogMethods
+
+        def send_request
+          setup_connection
+          connect_to_rpc_server
+          post_init
+          read_response
+        end
+
+        def log_signature
+          @_log_signature ||= "[client-#{self.class}]"
+        end
+
+        private
+
+        def close_connection
+          @socket.close
+          log_debug { sign_message('Connector closed')  }
+        end
+
+        def connect_to_rpc_server
+          @socket = TCPSocket.new(options[:host], options[:port])
+          log_debug { sign_message("Connection established #{options[:host]}:#{options[:port]}")  }
+        end
+
+        # Method to determine error state, must be used with Connector api
+        def error?
+          return true if @error
+          log_debug { sign_message("Error state : #{@socket.closed?}")  }
+          @socket.closed?
+        end
+
+        def read_data
+          size_io = StringIO.new
+
+          until (size_reader = @socket.getc) == "-"
+            size_io << size_reader
+          end
+          str_size_io = size_io.string
+
+          "#{str_size_io}-#{@socket.read(str_size_io.to_i)}"
+        end
+
+        def read_response
+          log_debug { sign_message("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
+          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 { sign_message("write closed") }
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require 'protobuf/rpc/connectors/base'
+
+module Protobuf
+  module Rpc
+    module Connectors
+      class Zmq < Base
+        include Protobuf::Rpc::Connectors::Common
+        include Protobuf::Logger::LogMethods
+
+        def send_request
+          setup_connection
+          connect_to_rpc_server
+          post_init
+          read_response
+        ensure
+          @socket.close if @socket
+          @zmq_context.terminate if @zmq_context
+          @zmq_context = nil
+        end
+
+        def log_signature
+          @_log_signature ||= "[client-#{self.class}]"
+        end
+
+        private
+
+        def close_connection
+          return if @error
+          zmq_error_check(@socket.close)
+          zmq_error_check(@zmq_context.terminate)
+          log_debug { sign_message("Connector closed")  }
+        end
+
+        def connect_to_rpc_server
+          return if @error
+          log_debug { sign_message("Establishing connection: #{options[:host]}:#{options[:port]}") }
+          @zmq_context = ::ZMQ::Context.new
+          @socket = @zmq_context.socket(::ZMQ::REQ)
+          zmq_error_check(@socket.connect("tcp://#{options[:host]}:#{options[:port]}"))
+          log_debug { sign_message("Connection established #{options[:host]}:#{options[:port]}") }
+        end
+
+        # Method to determine error state, must be used with Connector api
+        def error?
+          !!@error
+        end
+
+        def read_response
+          return if @error
+          @response_data = ''
+          zmq_error_check(@socket.recv_string(@response_data))
+          parse_response
+        end
+
+        def send_data
+          return if @error
+          log_debug { sign_message("Sending Request: #{@request_data}") }
+          @stats.request_size = @request_data.size
+          zmq_error_check(@socket.send_string(@request_data))
+          log_debug { sign_message("write closed") }
+        end
+
+        def zmq_error_check(return_code)
+          raise "Last API call failed at #{caller(1)}" unless return_code >= 0
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/error/client_error.rb

@@ -0,0 +1,31 @@
+require 'protobuf/rpc/error'
+
+module Protobuf
+  module Rpc
+    
+    class InvalidRequestProto < PbError
+      def initialize(message='Invalid request type given')
+        super message, 'INVALID_REQUEST_PROTO'
+      end
+    end
+    
+    class BadResponseProto < PbError
+      def initialize(message='Bad response type from server')
+        super message, 'BAD_RESPONSE_PROTO'
+      end
+    end
+    
+    class UnkownHost < PbError
+      def initialize(message='Unknown host or port')
+        super message, 'UNKNOWN_HOST'
+      end
+    end
+    
+    class IOError < PbError
+      def initialize(message='IO Error occurred')
+        super message, 'IO_ERROR'
+      end
+    end
+    
+  end
+end

data/lib/protobuf/rpc/error/server_error.rb

@@ -0,0 +1,43 @@
+require 'protobuf/rpc/rpc.pb'
+
+module Protobuf
+  module Rpc
+    
+    class BadRequestData < PbError
+      def initialize message='Unable to parse request'
+        super message, 'BAD_REQUEST_DATA'
+      end
+    end
+    
+    class BadRequestProto < PbError
+      def initialize message='Request is of wrong type'
+        super message, 'BAD_REQUEST_PROTO'
+      end
+    end
+    
+    class ServiceNotFound < PbError
+      def initialize message='Service class not found'
+        super message, 'SERVICE_NOT_FOUND'
+      end
+    end
+    
+    class MethodNotFound < PbError
+      def initialize message='Service method not found'
+        super message, 'METHOD_NOT_FOUND'
+      end
+    end
+    
+    class RpcError < PbError
+      def initialize message='RPC exception occurred'
+        super message, 'RPC_ERROR'
+      end
+    end
+    
+    class RpcFailed < PbError
+      def initialize message='RPC failed'
+        super message, 'RPC_FAILED'
+      end
+    end
+    
+  end
+end

data/lib/protobuf/rpc/error.rb

@@ -0,0 +1,25 @@
+require 'protobuf/rpc/rpc.pb'
+
+module Protobuf
+  module Rpc
+    ClientError = Struct.new("ClientError", :code, :message)
+
+    # Base PbError class for client and server errors
+    class PbError < StandardError
+      attr_reader :error_type
+
+      def initialize message='An unknown RpcError occurred', error_type='RPC_ERROR'
+        @error_type = error_type.is_a?(String) ? ::Protobuf::Socketrpc::ErrorReason.const_get(error_type) : error_type
+        super message
+      end
+
+      def to_response response
+        response.error = message
+        response.error_reason = @error_type
+      end
+    end
+  end
+end
+
+require 'protobuf/rpc/error/server_error'
+require 'protobuf/rpc/error/client_error'