protobuffy 3.6.0 → 4.0.0

data/lib/protobuf/rpc/client.rb

@@ -1,16 +1,15 @@
 require 'forwardable'
 require 'protobuf'
-require 'protobuf/logger'
+require 'protobuf/logging'
 require 'protobuf/rpc/error'
-require 'protobuf/rpc/connector'
 
 module Protobuf
   module Rpc
     class Client
       extend Forwardable
-      include Protobuf::Logger::LogMethods
+      include Protobuf::Logging
 
-      def_delegators :@connector, :options, :complete_cb, :success_cb, :failure_cb
+      def_delegators :@connector, :options, :complete_cb, :success_cb, :failure_cb, :send_request
       attr_reader :connector
 
       # Create a new client with default options (defined in ClientConnection)
@@ -27,9 +26,9 @@ module Protobuf
       #   })
       #
       def initialize(options = {})
-        raise "Invalid client configuration. Service must be defined." if options[:service].nil?
-        @connector = Connector.connector_for_client.new(options)
-        log_debug { sign_message("Initialized with options: #{options.inspect}") }
+        fail "Invalid client configuration. Service must be defined." if options[:service].nil?
+        @connector = ::Protobuf.connector_type_class.new(options)
+        logger.debug { sign_message("Initialized with options: #{options.inspect}") }
       end
 
       def log_signature
@@ -46,8 +45,8 @@ module Protobuf
       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"
+        if !callable.nil? && !callable.respond_to?(:call) && callable.arity != 1
+          fail "callable must take a single argument and respond to :call"
         end
 
         @connector.complete_cb = callable
@@ -65,8 +64,8 @@ module Protobuf
       end
 
       def on_failure=(callable)
-        if callable != nil && !callable.respond_to?(:call) && callable.arity != 1
-          raise "Callable must take a single argument and respond to :call"
+        if !callable.nil? && !callable.respond_to?(:call) && callable.arity != 1
+          fail "Callable must take a single argument and respond to :call"
         end
 
         @connector.failure_cb = callable
@@ -84,8 +83,8 @@ module Protobuf
       end
 
       def on_success=(callable)
-        if callable != nil && !callable.respond_to?(:call) && callable.arity != 1
-          raise "Callable must take a single argument and respond to :call"
+        if !callable.nil? && !callable.respond_to?(:call) && callable.arity != 1
+          fail "Callable must take a single argument and respond to :call"
         end
 
         @connector.success_cb = callable
@@ -105,62 +104,35 @@ module Protobuf
       #
       def method_missing(method_name, *params)
         service = options[:service]
-        unless service.rpc_method?(method_name)
-          log_error { sign_message("#{service.name}##{method_name.to_s} not rpc method, passing to super") }
-          super(method_name, *params)
-        else
-          log_debug { sign_message("#{service.name}##{method_name.to_s}") }
+        if service.rpc_method?(method_name)
+          logger.debug { sign_message("#{service.name}##{method_name}") }
           rpc = service.rpcs[method_name.to_sym]
 
           options[:request_type] = rpc.request_type
-          log_debug { sign_message("Request Type: #{options[:request_type].name}") }
+          logger.debug { sign_message("Request Type: #{options[:request_type].name}") }
 
           options[:response_type] = rpc.response_type
-          log_debug { sign_message("Response Type: #{options[:response_type].name}") }
+          logger.debug { sign_message("Response Type: #{options[:response_type].name}") }
 
           options[:method] = method_name.to_s
           options[:request] = params[0].is_a?(Hash) ? options[:request_type].new(params[0]) : params[0]
-          log_debug { sign_message("Request Data: #{options[:request].inspect}") }
+          logger.debug { sign_message("Request Data: #{options[:request].inspect}") }
 
           # Call client to setup on_success and on_failure event callbacks
           if block_given?
-            log_debug { sign_message("client setup callback given, invoking") }
+            logger.debug { sign_message("client setup callback given, invoking") }
             yield(self)
           else
-            log_debug { sign_message("no block given for callbacks") }
+            logger.debug { sign_message("no block given for callbacks") }
           end
 
           send_request
+        else
+          logger.error { sign_message("#{service.name}##{method_name} not rpc method, passing to super") }
+          super(method_name, *params)
         end
       end
 
-      # Send the request to the service.
-      # This method is usually never called directly
-      # but is invoked by method_missing (see docs above).
-      #
-      #   request = WidgetFindRequest.new
-      #   client = Client.new({
-      #     :service => WidgetService,
-      #     :method => "find",
-      #     :request_type => "WidgetFindRequest",
-      #     :response_type => "WidgetList",
-      #     :request => request
-      #   })
-      #
-      #   client.on_success do |res|
-      #     res.widgets.each{|w| puts w.inspect }
-      #   end
-      #
-      #   client.on_failure do |err|
-      #     puts err.message
-      #   end
-      #
-      #   client.send_request
-      #
-      def send_request
-        @connector.send_request
-      end
-
     end
 
     ActiveSupport.run_load_hooks(:protobuf_rpc_client, Client)

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

@@ -1,10 +1,9 @@
 require 'timeout'
-require 'protobuf/logger'
+require 'protobuf/logging'
 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
@@ -17,28 +16,117 @@ module Protobuf
         :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                 => 300,         # The default timeout for the request, also handled by client.rb
+        :timeout                 => nil,         # The timeout for the request, also handled by client.rb
         :client_host             => nil,         # The hostname or address of this client
-        :first_alive_load_balance => false,       # Do we want to use check_avail frames before request
-      }
+        :first_alive_load_balance => false,      # Do we want to use check_avail frames before request
+      }.freeze
 
       class Base
-        include Protobuf::Logger::LogMethods
+        include Protobuf::Logging
 
-        attr_reader :options
-        attr_accessor :success_cb, :failure_cb, :complete_cb
+        attr_reader :options, :error
+        attr_accessor :success_cb, :failure_cb, :complete_cb, :stats
 
         def initialize(options)
           @options = DEFAULT_OPTIONS.merge(options)
+          @stats = ::Protobuf::Rpc::Stat.new(:CLIENT)
+        end
+
+        def any_callbacks?
+          [@complete_cb, @failure_cb, @success_cb].any?
+        end
+
+        def close_connection
+          fail 'If you inherit a Connector from Base you must implement close_connection'
+        end
+
+        def complete
+          @stats.stop
+          logger.info { @stats.to_s }
+          logger.debug { sign_message('Response proceessing complete') }
+          @complete_cb.call(self) unless @complete_cb.nil?
+        rescue => e
+          logger.error { sign_message('Complete callback error encountered') }
+          log_exception(e)
+          raise
+        end
+
+        def data_callback(data)
+          logger.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 failure(code, message)
+          @error = ClientError.new
+          @error.code = ::Protobuf::Socketrpc::ErrorReason.fetch(code)
+          @error.message = message
+          logger.debug { sign_message("Server failed request (invoking on_failure): #{@error.inspect}") }
+
+          @stats.failure(code)
+          @failure_cb.call(@error) unless @failure_cb.nil?
+        rescue => e
+          logger.error { sign_message("Failure callback error encountered") }
+          log_exception(e)
+          raise
+        ensure
+          complete
         end
 
         def first_alive_load_balance?
-          ENV.has_key?("PB_FIRST_ALIVE_LOAD_BALANCE") ||
+          ENV.key?("PB_FIRST_ALIVE_LOAD_BALANCE") ||
             options[:first_alive_load_balance]
         end
 
-        def send_request
-          raise 'If you inherit a Connector from Base you must implement send_request'
+        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)
+          failure(: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
+
+          logger.debug { sign_message("Parsing response from server (connection closed)") }
+
+          # Parse out the raw response
+          @stats.response_size = @response_data.size unless @response_data.nil?
+          response_wrapper = ::Protobuf::Socketrpc::Response.decode(@response_data)
+
+          # Determine success or failure based on parsed data
+          if response_wrapper.field?(:error_reason)
+            logger.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)
+            failure(response_wrapper.error_reason, response_wrapper.error)
+          else
+            logger.debug { sign_message("Successful response parsed") }
+
+            # Ensure client_response is an instance
+            parsed = @options[:response_type].decode(response_wrapper.response_proto.to_s)
+
+            if parsed.nil? && !response_wrapper.field?(:error_reason)
+              failure(:BAD_RESPONSE_PROTO, 'Unable to parse response from server')
+            else
+              verify_callbacks
+              succeed(parsed)
+              return @data if @used_data_callback
+            end
+          end
         end
 
         def ping_port
@@ -46,8 +134,85 @@ module Protobuf
         end
 
         def ping_port_enabled?
-          ENV.has_key?("PB_RPC_PING_PORT")
+          ENV.key?("PB_RPC_PING_PORT")
         end
+
+        def request_bytes
+          validate_request_type!
+          fields = { :service_name => @options[:service].name,
+                     :method_name => @options[:method].to_s,
+                     :request_proto => @options[:request],
+                     :caller => request_caller }
+
+          return ::Protobuf::Socketrpc::Request.encode(fields)
+        rescue => e
+          failure(:INVALID_REQUEST_PROTO, "Could not set request proto: #{e.message}")
+        end
+
+        def request_caller
+          @options[:client_host] || ::Protobuf.client_host
+        end
+
+        def send_request
+          fail 'If you inherit a Connector from Base you must implement send_request'
+        end
+
+        def setup_connection
+          initialize_stats
+          @request_data = request_bytes
+          @stats.request_size = @request_data.size
+        end
+
+        def succeed(response)
+          logger.debug { sign_message("Server succeeded request (invoking on_success)") }
+          @stats.success
+          @success_cb.call(response) unless @success_cb.nil?
+        rescue => e
+          logger.error { sign_message("Success callback error encountered") }
+          log_exception(e)
+          failure(:RPC_ERROR, "An exception occurred while calling on_success: #{e.message}")
+        ensure
+          complete
+        end
+
+        def timeout
+          if options[:timeout]
+            options[:timeout]
+          else
+            300 # seconds
+          end
+        end
+
+        # Wrap the given block in a timeout of the configured number of seconds.
+        #
+        def timeout_wrap(&block)
+          ::Timeout.timeout(timeout, &block)
+        rescue ::Timeout::Error
+          failure(:RPC_FAILED, "The server took longer than #{timeout} seconds to respond")
+        end
+
+        def validate_request_type!
+          unless @options[:request].class == @options[:request_type]
+            expected = @options[:request_type].name
+            actual = @options[:request].class.name
+            failure(:INVALID_REQUEST_PROTO, "Expected request type to be type of #{expected}, got #{actual} instead")
+          end
+        end
+
+        def verify_callbacks
+          unless any_callbacks?
+            logger.debug { sign_message("No callbacks set, using data_callback") }
+            @success_cb = @failure_cb = 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|
+            failure(:RPC_ERROR, "Invalid client connection configuration. #{opt} must be a defined option.") if @options[opt].nil?
+          end
+        end
+
       end
     end
   end

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

@@ -6,8 +6,7 @@ module Protobuf
   module Rpc
     module Connectors
       class Http < Base
-        include Protobuf::Rpc::Connectors::Common
-        include Protobuf::Logger::LogMethods
+        include ::Protobuf::Logging
 
         def send_request
           timeout_wrap do
@@ -23,12 +22,12 @@ module Protobuf
         # private
 
         def close_connection
-          log_debug { sign_message('Connector closed')  }
+          logger.debug { sign_message('Connector closed') }
         end
 
         # Method to determine error state, must be used with Connector api
         def error?
-          log_debug { sign_message("Error state : #{@error}")  }
+          logger.debug { sign_message("Error state : #{@error}") }
           if @error
             true
           else
@@ -41,31 +40,37 @@ module Protobuf
         end
 
         def base
-          options[:base] or ''
+          options[:base] || ''
         end
 
         def client
           @_client ||= Faraday.new(:url => host)
         end
 
+        def post_init
+          send_data unless error?
+        rescue => e
+          fail(:RPC_ERROR, "Connection error: #{e.message}")
+        end
+
         def send_data
           rpc_request = ::Protobuf::Socketrpc::Request.decode(@request_data)
 
           http_response = client.post do |http_request|
             path_components = [''] + rpc_request[:service_name].split('::') + [rpc_request[:method_name]]
-            http_request.url base + path_components.map{ |x| CGI::escape(x) }.join('/')
+            http_request.url base + path_components.map { |x| CGI.escape(x) }.join('/')
             http_request.headers['Content-Type'] = 'application/x-protobuf'
             http_request.headers['X-Protobuf-Caller'] = rpc_request[:caller] || ''
             http_request.body = rpc_request[:request_proto]
           end
 
           # Server returns protobuf response with no error
-          if http_response.status == 200 and http_response.headers['x-protobuf-error'].nil?
+          if http_response.status == 200 && http_response.headers['x-protobuf-error'].nil?
             rpc_response = Protobuf::Socketrpc::Response.new(
               :response_proto => http_response.body
             )
           # Server returns protobuf error
-          elsif http_response.status != 200 and not http_response.headers['x-protobuf-error'].nil?
+          elsif http_response.status != 200 && http_response.headers['x-protobuf-error']
             rpc_response = Protobuf::Socketrpc::Response.new(
               :response_proto => http_response.body,
               :error => http_response.headers['x-protobuf-error'],
@@ -80,7 +85,7 @@ module Protobuf
             )
           end
 
-          @response_data = rpc_response.encode()
+          @response_data = rpc_response.encode
 
           parse_response
         end

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

@@ -0,0 +1,89 @@
+require "socket"
+
+module Protobuf
+  module Rpc
+    module Connectors
+      class Ping
+        attr_reader :host, :port
+
+        def initialize(host, port)
+          @host = host
+          @port = port
+        end
+
+        def online?
+          socket = tcp_socket
+          socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_LINGER, [1, 0].pack('ii'))
+
+          true
+        rescue
+          false
+        ensure
+          begin
+            socket && socket.close
+          rescue IOError
+            nil
+          end
+        end
+
+        def timeout
+          @timeout ||= begin
+            if ::ENV.key?("PB_RPC_PING_PORT_TIMEOUT")
+              ::ENV["PB_RPC_PING_PORT_TIMEOUT"].to_f / 1000
+            else
+              0.2 # 200 ms
+            end
+          end
+        end
+
+        private
+
+        def tcp_socket
+          # Reference: http://stackoverflow.com/a/21014439/1457934
+          socket = ::Socket.new(family, ::Socket::SOCK_STREAM, 0)
+          socket.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+          socket.connect_nonblock(sockaddr)
+          socket
+        rescue ::IO::WaitWritable
+          # IO.select will block until the socket is writable or the timeout
+          # is exceeded - whichever comes first.
+          if ::IO.select(nil, [socket], nil, timeout)
+            begin
+              # Verify there is now a good connection
+              socket.connect_nonblock(sockaddr)
+              socket
+            rescue ::Errno::EISCONN
+              # Socket is connected.
+              socket
+            rescue
+              # An unexpected exception was raised - the connection is no good.
+              socket.close
+              raise
+            end
+          else
+            # IO.select returns nil when the socket is not ready before timeout
+            # seconds have elapsed
+            socket.close
+            raise "Connection Timeout"
+          end
+        end
+
+        def family
+          @family ||= ::Socket.const_get(addrinfo[0][0])
+        end
+
+        def addrinfo
+          @addrinfo ||= ::Socket.getaddrinfo(host, nil)
+        end
+
+        def ip
+          @ip ||= addrinfo[0][3]
+        end
+
+        def sockaddr
+          @sockaddr ||= ::Socket.pack_sockaddr_in(port, ip)
+        end
+      end
+    end
+  end
+end