protobuf-cucumber 3.10.4

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

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

@@ -0,0 +1,78 @@
+require 'protobuf/rpc/connectors/base'
+
+module Protobuf
+  module Rpc
+    module Connectors
+      class Socket < Base
+        include Protobuf::Logging
+
+        def send_request
+          timeout_wrap do
+            setup_connection
+            connect_to_rpc_server
+            post_init
+            read_response
+          end
+        end
+
+        def log_signature
+          @_log_signature ||= "[client-#{self.class}]"
+        end
+
+        private
+
+        def close_connection
+          @socket.close
+          logger.debug { sign_message('Connector closed') }
+        end
+
+        def connect_to_rpc_server
+          @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
+          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
+
+          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
+          logger.debug { sign_message("error? is #{error?}") }
+          return if error?
+          response_buffer = ::Protobuf::Rpc::Buffer.new(:read)
+          response_buffer << read_data
+          @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
+          logger.debug { sign_message("write closed") }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,319 @@
+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::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(reload = false)
+          @zmq_contexts = nil if reload
+          @zmq_contexts ||= Hash.new do |hash, key|
+            hash[key] = ZMQ::Context.new
+          end
+
+          @zmq_contexts[Process.pid]
+        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.
+        #
+        # @see http://zguide.zeromq.org/php:chapter4#Client-side-Reliability-Lazy-Pirate-Pattern
+        #
+        def send_request
+          setup_connection
+          send_request_with_lazy_pirate unless error?
+        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.
+        end
+
+        # Create a socket connected to a server that can handle the current
+        # service. The LINGER is set to 0 so we can close immediately in
+        # the event of a timeout
+        def create_socket
+          attempt_number = 0
+
+          begin
+            attempt_number += 1
+            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)
+              socket = socket_to_available_server(socket) if first_alive_load_balance?
+            end
+          end while socket.try(:socket).nil? && attempt_number < socket_creation_attempts
+
+          raise RequestTimeout, "Cannot create new ZMQ client socket" if socket.try(:socket).nil?
+          socket
+        end
+
+        # Method to determine error state, must be used with Connector API.
+        #
+        def error?
+          !! @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
+          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)
+          Ping.new(host, ping_port.to_i).online?
+        end
+
+        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.
+        # 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
+
+        def send_request_with_timeout(attempt = 0)
+          socket = create_socket
+          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
+          logger.debug { sign_message("Closing Socket") }
+          zmq_error_check(socket.close, :socket_close) if socket
+          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
+        #
+        def service
+          options[:service]
+        end
+
+        # Alias for ::Protobuf::Rpc::ServiceDirectory.instance
+        def service_directory
+          ::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_creation_attempts
+          @socket_creation_attempts ||= (ENV["PB_ZMQ_CLIENT_SOCKET_CREATION_ATTEMPTS"] || 5).to_i
+        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.
+        #
+        def zmq_context(reload = false)
+          self.class.zmq_context(reload)
+        end
+
+        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($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
+end