protobuf 3.3.6 → 3.4.0

data/lib/protobuf/rpc/buffer.rb

@@ -9,7 +9,7 @@ module Protobuf
       # constantize this so we don't re-initialize the regex every time we need it
       SIZE_REGEX = /^\d+-/
 
-      def initialize(mode=:read)
+      def initialize(mode = :read)
         @flush = false
         @data = ""
         @size = 0
@@ -24,11 +24,11 @@ module Protobuf
         end
       end
 
-      def write(force_mode=true)
-        if force_mode and reading?
-          mode = :write
-        elsif not force_mode and reading?
-          raise = 'You chose to write the buffer when in read mode'
+      def write(force_mode = true)
+        if force_mode && reading?
+          self.mode = :write
+        elsif !force_mode && reading?
+          fail 'You chose to write the buffer when in read mode'
         end
 
         @size = @data.length
@@ -43,7 +43,7 @@ module Protobuf
         end
       end
 
-      def set_data(data)
+      def set_data(data) # rubocop:disable Style/AccessorMethodName
         @data = data.to_s
         @size = @data.size
       end
@@ -60,19 +60,17 @@ module Protobuf
         @flush
       end
 
-      def get_data_size
+      def get_data_size # rubocop:disable Style/AccessorMethodName
         if @size == 0 || @data.match(SIZE_REGEX)
           sliced_size = @data.slice!(SIZE_REGEX)
           @size = sliced_size.gsub('-', '').to_i unless sliced_size.nil?
         end
       end
 
-    private
+      private
 
       def check_for_flush
-        if !@size.nil? && @data.length == @size
-          @flush = true
-        end
+        @flush = true if !@size.nil? && @data.length == @size
       end
     end
   end

data/lib/protobuf/rpc/client.rb

@@ -27,7 +27,7 @@ module Protobuf
       #   })
       #
       def initialize(options = {})
-        raise "Invalid client configuration. Service must be defined." if options[:service].nil?
+        fail "Invalid client configuration. Service must be defined." if options[:service].nil?
         @connector = Connector.connector_for_client.new(options)
         logger.debug { sign_message("Initialized with options: #{options.inspect}") }
       end
@@ -46,8 +46,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 +65,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 +84,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,11 +105,8 @@ module Protobuf
       #
       def method_missing(method_name, *params)
         service = options[:service]
-        unless service.rpc_method?(method_name)
-          logger.error { sign_message("#{service.name}##{method_name.to_s} not rpc method, passing to super") }
-          super(method_name, *params)
-        else
-          logger.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
@@ -131,6 +128,9 @@ module Protobuf
           end
 
           send_request
+        else
+          logger.error { sign_message("#{service.name}##{method_name} not rpc method, passing to super") }
+          super(method_name, *params)
         end
       end
 

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

@@ -30,15 +30,16 @@ module Protobuf
 
         def initialize(options)
           @options = DEFAULT_OPTIONS.merge(options)
+          @stats = ::Protobuf::Rpc::Stat.new(:CLIENT)
         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'
+          fail 'If you inherit a Connector from Base you must implement send_request'
         end
 
         def ping_port
@@ -46,7 +47,7 @@ module Protobuf
         end
 
         def ping_port_enabled?
-          ENV.has_key?("PB_RPC_PING_PORT")
+          ENV.key?("PB_RPC_PING_PORT")
         end
       end
     end

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

@@ -8,9 +8,7 @@ module Protobuf
         attr_reader :error
 
         def any_callbacks?
-          return [@complete_cb, @failure_cb, @success_cb].inject(false) do |reduction, cb|
-            reduction = (reduction || !cb.nil?)
-          end
+          [@complete_cb, @failure_cb, @success_cb].any?
         end
 
         def request_caller
@@ -38,7 +36,7 @@ module Protobuf
         #
         # @param [Symbol] code The code we're using (see ::Protobuf::Socketrpc::ErrorReason)
         # @param [String] message The error message
-        def fail(code, message)
+        def failure(code, message)
           @error =  ClientError.new
           @error.code = Protobuf::Socketrpc::ErrorReason.fetch(code)
           @error.message = message
@@ -54,13 +52,13 @@ module Protobuf
         end
 
         def initialize_stats
-          @stats = Protobuf::Rpc::Stat.new(:CLIENT)
+          @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}")
+          failure(:RPC_ERROR, "Invalid stats configuration. #{ex.message}")
         end
 
         def log_signature
@@ -78,20 +76,20 @@ module Protobuf
           response_wrapper = Protobuf::Socketrpc::Response.decode(@response_data)
 
           # Determine success or failure based on parsed data
-          if response_wrapper.has_field?(:error_reason)
+          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)
-            fail(response_wrapper.error_reason, response_wrapper.error)
+            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? and not response_wrapper.has_field?(:error_reason)
-              fail(:BAD_RESPONSE_PROTO, 'Unable to parse response from server')
+            if parsed.nil? && !response_wrapper.field?(:error_reason)
+              failure(:BAD_RESPONSE_PROTO, 'Unable to parse response from server')
             else
               verify_callbacks
               succeed(parsed)
@@ -103,7 +101,7 @@ module Protobuf
         def post_init
           send_data unless error?
         rescue => e
-          fail(:RPC_ERROR, "Connection error: #{e.message}")
+          failure(:RPC_ERROR, "Connection error: #{e.message}")
         end
 
         def request_bytes
@@ -115,7 +113,7 @@ module Protobuf
 
           return ::Protobuf::Socketrpc::Request.encode(fields)
         rescue => e
-          fail(:INVALID_REQUEST_PROTO, "Could not set request proto: #{e.message}")
+          failure(:INVALID_REQUEST_PROTO, "Could not set request proto: #{e.message}")
         end
 
         def setup_connection
@@ -130,7 +128,7 @@ module Protobuf
         rescue => e
           logger.error { sign_message("Success callback error encountered") }
           log_exception(e)
-          fail(:RPC_ERROR, "An exception occurred while calling on_success: #{e.message}")
+          failure(:RPC_ERROR, "An exception occurred while calling on_success: #{e.message}")
         ensure
           complete
         end
@@ -148,28 +146,28 @@ module Protobuf
         def timeout_wrap(&block)
           ::Timeout.timeout(timeout, &block)
         rescue ::Timeout::Error
-          fail(:RPC_FAILED, "The server took longer than #{timeout} seconds to respond")
+          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
-            fail(:INVALID_REQUEST_PROTO, "Expected request type to be type of #{expected}, got #{actual} instead")
+            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 = self.method(: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|
-            fail(:RPC_ERROR, "Invalid client connection configuration. #{opt} must be a defined option.") if @options[opt].nil?
+            failure(:RPC_ERROR, "Invalid client connection configuration. #{opt} must be a defined option.") if @options[opt].nil?
           end
         end
       end

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

@@ -28,8 +28,8 @@ module Protobuf
         end
 
         def connect_to_rpc_server
-          @socket = TCPSocket.new(options[:host], options[:port])
-          logger.debug { sign_message("Connection established #{options[:host]}:#{options[:port]}")  }
+          @socket ||= TCPSocket.new(options[:host], options[:port])
+          logger.debug { sign_message("Connection established #{options[:host]}:#{options[:port]}") }
         end
 
         # Method to determine error state, must be used with Connector api

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

@@ -24,21 +24,24 @@ module Protobuf
         ##
         # Class Methods
         #
+        def self.ping_port_responses
+          @ping_port_responses ||= ::ThreadSafe::Cache.new
+        end
+
         def self.zmq_context
-          @zmq_contexts ||= Hash.new { |hash, key|
+          @zmq_contexts ||= Hash.new do |hash, key|
             hash[key] = ZMQ::Context.new
-          }
+          end
 
           @zmq_contexts[Process.pid]
         end
 
-        def self.ping_port_responses
-          @ping_port_responses ||= ::ThreadSafe::Cache.new
-        end
-
         ##
         # Instance methods
         #
+        def log_signature
+          @_log_signature ||= "[client-#{self.class}]"
+        end
 
         # Start the request/response cycle. We implement the Lazy Pirate
         # req/reply reliability pattern as laid out in the ZMQ Guide, Chapter 4.
@@ -50,10 +53,6 @@ module Protobuf
           send_request_with_lazy_pirate unless error?
         end
 
-        def log_signature
-          @_log_signature ||= "[client-#{self.class}]"
-        end
-
         private
 
         ##
@@ -75,34 +74,14 @@ module Protobuf
         # service. The LINGER is set to 0 so we can close immediately in
         # the event of a timeout
         def create_socket
-          socket = nil
+          socket = zmq_context.socket(::ZMQ::REQ)
 
           begin
-            server_uri = lookup_server_uri
-            socket = zmq_context.socket(::ZMQ::REQ)
-
             if socket # Make sure the context builds the socket
+              server_uri = lookup_server_uri
               socket.setsockopt(::ZMQ::LINGER, 0)
               zmq_error_check(socket.connect(server_uri), :socket_connect)
-
-              if first_alive_load_balance?
-                begin
-                  check_available_response = ""
-                  socket.setsockopt(::ZMQ::RCVTIMEO, check_available_rcv_timeout)
-                  socket.setsockopt(::ZMQ::SNDTIMEO, check_available_snd_timeout)
-                  zmq_recoverable_error_check(socket.send_string(::Protobuf::Rpc::Zmq::CHECK_AVAILABLE_MESSAGE), :socket_send_string)
-                  zmq_recoverable_error_check(socket.recv_string(check_available_response), :socket_recv_string)
-
-                  if check_available_response == ::Protobuf::Rpc::Zmq::NO_WORKERS_AVAILABLE
-                    zmq_recoverable_error_check(socket.close, :socket_close)
-                  end
-                rescue ZmqRecoverableError
-                  socket = nil # couldn't make a connection and need to try again
-                else
-                  socket.setsockopt(::ZMQ::RCVTIMEO, -1)
-                  socket.setsockopt(::ZMQ::SNDTIMEO, -1)
-                end
-              end
+              socket = socket_to_available_server(socket) if first_alive_load_balance?
             end
           end while socket.try(:socket).nil?
 
@@ -115,28 +94,6 @@ module Protobuf
           !! @error
         end
 
-        # Lookup a server uri for the requested service in the service
-        # directory. If the service directory is not running, default
-        # to the host and port in the options
-        #
-        def lookup_server_uri
-          server_lookup_attempts.times do
-            service_directory.all_listings_for(service).each do |listing|
-              host = listing.try(:address)
-              port = listing.try(:port)
-              return "tcp://#{host}:#{port}" if host_alive?(host)
-            end
-
-            host = options[:host]
-            port = options[:port]
-            return "tcp://#{host}:#{port}" if host_alive?(host)
-
-            sleep (1.0/100.0)
-          end
-
-          raise "Host not found for service #{service}"
-        end
-
         def host_alive?(host)
           return true unless ping_port_enabled?
 
@@ -149,7 +106,7 @@ module Protobuf
           ping_port_open = ping_port_open?(host)
           self.class.ping_port_responses[host] = {
             :at => Time.now.to_i,
-            :ping_port_open => ping_port_open
+            :ping_port_open => ping_port_open,
           }
           ping_port_open
         end
@@ -158,32 +115,50 @@ module Protobuf
           @host_alive_check_interval ||= [ENV["PB_ZMQ_CLIENT_HOST_ALIVE_CHECK_INTERVAL"].to_i, 1].max
         end
 
+        # Lookup a server uri for the requested service in the service
+        # directory. If the service directory is not running, default
+        # to the host and port in the options
+        #
+        def lookup_server_uri
+          server_lookup_attempts.times do
+            first_alive_listing = service_directory.all_listings_for(service).find do |listing|
+              host_alive?(listing.try(:address))
+            end
+
+            if first_alive_listing
+              host = first_alive_listing.try(:address)
+              port = first_alive_listing.try(:port)
+              @stats.server = [port, host]
+              return "tcp://#{host}:#{port}"
+            end
+
+            host = options[:host]
+            port = options[:port]
+
+            if host_alive?(host)
+              @stats.server = [port, host]
+              return "tcp://#{host}:#{port}"
+            end
+
+            sleep(1.0 / 100.0)
+          end
+
+          fail "Host not found for service #{service}"
+        end
+
         def ping_port_open?(host)
           socket = TCPSocket.new(host, ping_port.to_i)
           socket.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
-          socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_LINGER, [1,0].pack('ii'))
+          socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_LINGER, [1, 0].pack('ii'))
 
           true
         rescue
           false
         ensure
-          socket.close rescue nil
-        end
-
-        # Trying a number of times, attempt to get a response from the server.
-        # If we haven't received a legitimate response in the CLIENT_RETRIES number
-        # of retries, fail the request.
-        #
-        def send_request_with_lazy_pirate
-          attempt = 0
-
           begin
-            attempt += 1
-            send_request_with_timeout(attempt)
-            parse_response
-          rescue RequestTimeout
-            retry if attempt < CLIENT_RETRIES
-            fail(:RPC_FAILED, "The server repeatedly failed to respond within #{timeout} seconds")
+            socket && socket.close
+          rescue IOError
+            nil
           end
         end
 
@@ -192,7 +167,7 @@ module Protobuf
             case
             when options[:timeout] then
               options[:timeout]
-            when ENV.has_key?("PB_ZMQ_CLIENT_RCV_TIMEOUT") then
+            when ENV.key?("PB_ZMQ_CLIENT_RCV_TIMEOUT") then
               ENV["PB_ZMQ_CLIENT_RCV_TIMEOUT"].to_i
             else
               300_000 # 300 seconds
@@ -200,16 +175,20 @@ module Protobuf
           end
         end
 
-        def snd_timeout
-          @snd_timeout ||= begin
-            case
-            when options[:timeout] then
-              options[:timeout]
-            when ENV.has_key?("PB_ZMQ_CLIENT_SND_TIMEOUT") then
-              ENV["PB_ZMQ_CLIENT_SND_TIMEOUT"].to_i
-            else
-              300_000 # 300 seconds
-            end
+        # Trying a number of times, attempt to get a response from the server.
+        # If we haven't received a legitimate response in the CLIENT_RETRIES number
+        # of retries, fail the request.
+        #
+        def send_request_with_lazy_pirate
+          attempt = 0
+
+          begin
+            attempt += 1
+            send_request_with_timeout(attempt)
+            parse_response
+          rescue RequestTimeout
+            retry if attempt < CLIENT_RETRIES
+            failure(:RPC_FAILED, "The server repeatedly failed to respond within #{timeout} seconds")
           end
         end
 
@@ -247,6 +226,37 @@ module Protobuf
           ::Protobuf::Rpc::ServiceDirectory.instance
         end
 
+        def snd_timeout
+          @snd_timeout ||= begin
+            case
+            when options[:timeout] then
+              options[:timeout]
+            when ENV.key?("PB_ZMQ_CLIENT_SND_TIMEOUT") then
+              ENV["PB_ZMQ_CLIENT_SND_TIMEOUT"].to_i
+            else
+              300_000 # 300 seconds
+            end
+          end
+        end
+
+        def socket_to_available_server(socket)
+          check_available_response = ""
+          socket.setsockopt(::ZMQ::RCVTIMEO, check_available_rcv_timeout)
+          socket.setsockopt(::ZMQ::SNDTIMEO, check_available_snd_timeout)
+          zmq_recoverable_error_check(socket.send_string(::Protobuf::Rpc::Zmq::CHECK_AVAILABLE_MESSAGE), :socket_send_string)
+          zmq_recoverable_error_check(socket.recv_string(check_available_response), :socket_recv_string)
+
+          if check_available_response == ::Protobuf::Rpc::Zmq::NO_WORKERS_AVAILABLE
+            zmq_recoverable_error_check(socket.close, :socket_close)
+          end
+
+          socket.setsockopt(::ZMQ::RCVTIMEO, -1)
+          socket.setsockopt(::ZMQ::SNDTIMEO, -1)
+          socket
+        rescue ZmqRecoverableError
+          return nil # couldn't make a connection and need to try again
+        end
+
         # Return the ZMQ Context to use for this process.
         # If the context does not exist, create it, then register
         # an exit block to ensure the context is terminated correctly.
@@ -256,41 +266,41 @@ module Protobuf
         end
 
         def zmq_eagain_error_check(return_code, source)
-          unless ::ZMQ::Util.resultcode_ok?(return_code || -1)
-            if ::ZMQ::Util.errno == ::ZMQ::EAGAIN
-              raise ZmqEagainError, <<-ERROR
-              Last ZMQ API call to #{source} failed with "#{::ZMQ::Util.error_string}".
+          return if ::ZMQ::Util.resultcode_ok?(return_code || -1)
 
-              #{caller(1).join($/)}
-              ERROR
-            else
-              raise <<-ERROR
-              Last ZMQ API call to #{source} failed with "#{::ZMQ::Util.error_string}".
+          if ::ZMQ::Util.errno == ::ZMQ::EAGAIN
+            fail ZmqEagainError, <<-ERROR
+            Last ZMQ API call to #{source} failed with "#{::ZMQ::Util.error_string}".
 
-              #{caller(1).join($/)}
-              ERROR
-            end
+            #{caller(1).join($INPUT_RECORD_SEPARATOR)}
+            ERROR
+          else
+            fail <<-ERROR
+            Last ZMQ API call to #{source} failed with "#{::ZMQ::Util.error_string}".
+
+            #{caller(1).join($INPUT_RECORD_SEPARATOR)}
+            ERROR
           end
         end
 
         def zmq_error_check(return_code, source)
-          unless ::ZMQ::Util.resultcode_ok?(return_code || -1)
-            raise <<-ERROR
-            Last ZMQ API call to #{source} failed with "#{::ZMQ::Util.error_string}".
+          return if ::ZMQ::Util.resultcode_ok?(return_code || -1)
 
-            #{caller(1).join($/)}
-            ERROR
-          end
+          fail <<-ERROR
+          Last ZMQ API call to #{source} failed with "#{::ZMQ::Util.error_string}".
+
+          #{caller(1).join($INPUT_RECORD_SEPARATOR)}
+          ERROR
         end
 
         def zmq_recoverable_error_check(return_code, source)
-          unless ::ZMQ::Util.resultcode_ok?(return_code || -1)
-            raise ZmqRecoverableError, <<-ERROR
-              Last ZMQ API call to #{source} failed with "#{::ZMQ::Util.error_string}".
+          return if ::ZMQ::Util.resultcode_ok?(return_code || -1)
 
-              #{caller(1).join($/)}
-              ERROR
-          end
+          fail ZmqRecoverableError, <<-ERROR
+          Last ZMQ API call to #{source} failed with "#{::ZMQ::Util.error_string}".
+
+          #{caller(1).join($INPUT_RECORD_SEPARATOR)}
+          ERROR
         end
       end
     end