protobuffy 3.6.0 → 4.0.0

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

@@ -4,8 +4,7 @@ module Protobuf
   module Rpc
     module Connectors
       class Socket < Base
-        include Protobuf::Rpc::Connectors::Common
-        include Protobuf::Logger::LogMethods
+        include Protobuf::Logging
 
         def send_request
           timeout_wrap do
@@ -24,21 +23,27 @@ module Protobuf
 
         def close_connection
           @socket.close
-          log_debug { sign_message('Connector closed')  }
+          logger.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]}")  }
+          @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
         def error?
           return true if @error
-          log_debug { sign_message("Error state : #{@socket.closed?}")  }
+          logger.debug { sign_message("Error state : #{@socket.closed?}") }
           @socket.closed?
         end
 
+        def post_init
+          send_data unless error?
+        rescue => e
+          failure(:RPC_ERROR, "Connection error: #{e.message}")
+        end
+
         def read_data
           size_io = StringIO.new
 
@@ -51,7 +56,7 @@ module Protobuf
         end
 
         def read_response
-          log_debug { sign_message("error? is #{error?}") }
+          logger.debug { sign_message("error? is #{error?}") }
           return if error?
           response_buffer = ::Protobuf::Rpc::Buffer.new(:read)
           response_buffer << read_data
@@ -65,7 +70,7 @@ module Protobuf
           request_buffer.set_data(@request_data)
           @socket.write(request_buffer.write)
           @socket.flush
-          log_debug { sign_message("write closed") }
+          logger.debug { sign_message("write closed") }
         end
       end
     end

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

@@ -1,33 +1,37 @@
-require 'protobuf/rpc/connectors/base'
-require 'protobuf/rpc/service_directory'
+require "thread_safe"
+require "protobuf/rpc/connectors/base"
+require "protobuf/rpc/connectors/ping"
+require "protobuf/rpc/service_directory"
 
 module Protobuf
   module Rpc
     module Connectors
       class Zmq < Base
-
         RequestTimeout = Class.new(RuntimeError)
+        ZmqRecoverableError = Class.new(RuntimeError)
+        ZmqEagainError = Class.new(RuntimeError)
 
         ##
         # Included Modules
         #
-
-        include Protobuf::Rpc::Connectors::Common
-        include Protobuf::Logger::LogMethods
+        include Protobuf::Logging
 
         ##
         # Class Constants
         #
-
         CLIENT_RETRIES = (ENV['PB_CLIENT_RETRIES'] || 3)
 
         ##
         # 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
@@ -35,6 +39,9 @@ module Protobuf
         ##
         # 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.
@@ -46,15 +53,32 @@ module Protobuf
           send_request_with_lazy_pirate unless error?
         end
 
-        def log_signature
-          @_log_signature ||= "[client-#{self.class}]"
-        end
-
         private
 
         ##
         # Private Instance methods
         #
+        def check_available_rcv_timeout
+          @check_available_rcv_timeout ||= begin
+            case
+            when ENV.key?("PB_ZMQ_CLIENT_CHECK_AVAILABLE_RCV_TIMEOUT") then
+              ENV["PB_ZMQ_CLIENT_CHECK_AVAILABLE_RCV_TIMEOUT"].to_i
+            else
+              200 # ms
+            end
+          end
+        end
+
+        def check_available_snd_timeout
+          @check_available_snd_timeout ||= begin
+            case
+            when ENV.key?("PB_ZMQ_CLIENT_CHECK_AVAILABLE_SND_TIMEOUT") then
+              ENV["PB_ZMQ_CLIENT_CHECK_AVAILABLE_SND_TIMEOUT"].to_i
+            else
+              200 # ms
+            end
+          end
+        end
 
         def close_connection
           # The socket is automatically closed after every request.
@@ -64,26 +88,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
-
           begin
-            server_uri = lookup_server_uri
-
             socket = zmq_context.socket(::ZMQ::REQ)
-            socket.setsockopt(::ZMQ::LINGER, 0)
-
-            log_debug { sign_message("Establishing connection: #{server_uri}") }
-            zmq_error_check(socket.connect(server_uri), :socket_connect)
-            log_debug { sign_message("Connection established to #{server_uri}") }
-
-            if first_alive_load_balance?
-              check_available_response = ""
-              zmq_error_check(socket.send_string(::Protobuf::Rpc::Zmq::CHECK_AVAILABLE_MESSAGE), :socket_send_string)
-              zmq_error_check(socket.recv_string(check_available_response), :socket_recv_string)
 
-              if check_available_response == ::Protobuf::Rpc::Zmq::NO_WORKERS_AVAILABLE
-                zmq_error_check(socket.close, :socket_close)
-              end
+            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)
+              socket = socket_to_available_server(socket) if first_alive_load_balance?
             end
           end while socket.try(:socket).nil?
 
@@ -96,38 +108,73 @@ module Protobuf
           !! @error
         end
 
+        def host_alive?(host)
+          return true unless ping_port_enabled?
+
+          if (last_response = self.class.ping_port_responses[host])
+            if (Time.now.to_i - last_response[:at]) <= host_alive_check_interval
+              return last_response[:ping_port_open]
+            end
+          end
+
+          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
+        end
+
+        def host_alive_check_interval
+          @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
-          50.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)
+          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]
-            return "tcp://#{host}:#{port}" if host_alive?(host)
 
-            sleep(1.0/10.0) # not sure why sleeping at all, but should be way less than 1 second
+            if host_alive?(host)
+              @stats.server = [port, host]
+              return "tcp://#{host}:#{port}"
+            end
+
+            sleep(1.0 / 100.0)
           end
 
-          raise "Host not found for service #{service}"
+          fail "Host not found for service #{service}"
         end
 
-        def host_alive?(host)
-          return true unless ping_port_enabled?
-
-          socket = TCPSocket.new(host, ping_port.to_i)
+        def ping_port_open?(host)
+          Ping.new(host, ping_port.to_i).online?
+        end
 
-          true
-        rescue
-          false
-        ensure
-          socket.close rescue nil
+        def rcv_timeout
+          @rcv_timeout ||= begin
+            case
+            when options[:timeout] then
+              options[:timeout]
+            when ENV.key?("PB_ZMQ_CLIENT_RCV_TIMEOUT") then
+              ENV["PB_ZMQ_CLIENT_RCV_TIMEOUT"].to_i
+            else
+              300_000 # 300 seconds
+            end
+          end
         end
 
         # Trying a number of times, attempt to get a response from the server.
@@ -136,39 +183,38 @@ module Protobuf
         #
         def send_request_with_lazy_pirate
           attempt = 0
-          timeout = options[:timeout].to_f
 
           begin
             attempt += 1
-            send_request_with_timeout(timeout, attempt)
+            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")
+            failure(:RPC_FAILED, "The server repeatedly failed to respond within #{timeout} seconds")
           end
         end
 
-        def send_request_with_timeout(timeout, attempt = 0)
+        def send_request_with_timeout(attempt = 0)
           socket = create_socket
-
-          poller = ::ZMQ::Poller.new
-          poller.register_readable(socket)
-
-          log_debug { sign_message("Sending Request (attempt #{attempt}, #{socket})") }
-          zmq_error_check(socket.send_string(@request_data), :socket_send_string)
-          log_debug { sign_message("Waiting #{timeout} seconds for response (attempt #{attempt}, #{socket})") }
-
-          if poller.poll(timeout * 1000) == 1
-            zmq_error_check(socket.recv_string(@response_data = ""), :socket_recv_string)
-            log_debug { sign_message("Response received (attempt #{attempt}, #{socket})") }
-          else
-            log_debug { sign_message("Timed out waiting for response (attempt #{attempt}, #{socket})") }
-            raise RequestTimeout
-          end
+          socket.setsockopt(::ZMQ::RCVTIMEO, rcv_timeout)
+          socket.setsockopt(::ZMQ::SNDTIMEO, snd_timeout)
+
+          logger.debug { sign_message("Sending Request (attempt #{attempt}, #{socket})") }
+          zmq_eagain_error_check(socket.send_string(@request_data), :socket_send_string)
+          logger.debug { sign_message("Waiting #{rcv_timeout}ms for response (attempt #{attempt}, #{socket})") }
+          zmq_eagain_error_check(socket.recv_string(@response_data = ""), :socket_recv_string)
+          logger.debug { sign_message("Response received (attempt #{attempt}, #{socket})") }
+        rescue ZmqEagainError
+          logger.debug { sign_message("Timed out waiting for response (attempt #{attempt}, #{socket})") }
+          raise RequestTimeout
         ensure
-          log_debug { sign_message("Closing Socket")  }
+          logger.debug { sign_message("Closing Socket") }
           zmq_error_check(socket.close, :socket_close) if socket
-          log_debug { sign_message("Socket closed")  }
+          logger.debug { sign_message("Socket closed") }
+        end
+
+        def server_lookup_attempts
+          @server_lookup_attempts ||= [ENV["PB_ZMQ_CLIENT_SERVER_LOOKUP_ATTEMPTS"].to_i, 5].max
         end
 
         # The service we're attempting to connect to
@@ -179,7 +225,38 @@ module Protobuf
 
         # Alias for ::Protobuf::Rpc::ServiceDirectory.instance
         def service_directory
-          ::Protobuf::Rpc::ServiceDirectory.instance
+          ::Protobuf::Rpc.service_directory
+        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.
@@ -190,15 +267,43 @@ module Protobuf
           self.class.zmq_context
         end
 
-        def zmq_error_check(return_code, source)
-          unless ::ZMQ::Util.resultcode_ok?(return_code || -1)
-            raise <<-ERROR
+        def zmq_eagain_error_check(return_code, source)
+          return if ::ZMQ::Util.resultcode_ok?(return_code || -1)
+
+          if ::ZMQ::Util.errno == ::ZMQ::EAGAIN # rubocop:disable Style/GuardClause
+            fail ZmqEagainError, <<-ERROR
+            Last ZMQ API call to #{source} failed with "#{::ZMQ::Util.error_string}".
+
+            #{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($/)}
+            #{caller(1).join($INPUT_RECORD_SEPARATOR)}
             ERROR
           end
         end
+
+        def zmq_error_check(return_code, source)
+          return if ::ZMQ::Util.resultcode_ok?(return_code || -1)
+
+          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)
+          return if ::ZMQ::Util.resultcode_ok?(return_code || -1)
+
+          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
   end

data/lib/protobuf/rpc/dynamic_discovery.pb.rb

@@ -1,11 +1,14 @@
+# encoding: utf-8
+
 ##
 # This file is auto-generated. DO NOT EDIT!
 #
-require 'protobuf/message'
+require 'protobuf'
 
 module Protobuf
   module Rpc
     module DynamicDiscovery
+      ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions }
 
       ##
       # Enum Classes

data/lib/protobuf/rpc/env.rb

@@ -16,19 +16,19 @@ module Protobuf
       #
       def self.hash_accessor(*names) #:nodoc:
         names.each do |name|
-          class_eval <<-METHOD, __FILE__, __LINE__ + 1
-            def #{name}
-              self['#{name}']
-            end
+          name_str = name.to_s.freeze
 
-            def #{name}=(value)
-              self['#{name}'] = value
-            end
+          define_method name do
+            self[name_str]
+          end
 
-            def #{name}?
-              ! self['#{name}'].nil?
-            end
-          METHOD
+          define_method "#{name}=" do |value|
+            self[name_str] = value
+          end
+
+          define_method "#{name}?" do
+            !self[name_str].nil?
+          end
         end
       end
 
@@ -49,7 +49,7 @@ module Protobuf
                     :service_name,
                     :worker_id
 
-      def initialize(options={})
+      def initialize(options = {})
         merge!(options)
 
         self['worker_id'] = ::Thread.current.object_id.to_s(16)