prepor-protobuf 3.5.0

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

@@ -0,0 +1,322 @@
+require 'thread_safe'
+require 'protobuf/rpc/connectors/base'
+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::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 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
+          begin
+            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?
+
+          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)
+          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'))
+
+          true
+        rescue
+          false
+        ensure
+          begin
+            socket && socket.close
+          rescue IOError
+            nil
+          end
+        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::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.
+        #
+        def zmq_context
+          self.class.zmq_context
+        end
+
+        def zmq_eagain_error_check(return_code, source)
+          return if ::ZMQ::Util.resultcode_ok?(return_code || -1)
+
+          if ::ZMQ::Util.errno == ::ZMQ::EAGAIN
+            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

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

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+##
+# This file is auto-generated. DO NOT EDIT!
+#
+require 'protobuf/message'
+
+module Protobuf
+  module Rpc
+    module DynamicDiscovery
+
+      ##
+      # Enum Classes
+      #
+      class BeaconType < ::Protobuf::Enum
+        define :HEARTBEAT, 0
+        define :FLATLINE, 1
+      end
+
+
+      ##
+      # Message Classes
+      #
+      class Server < ::Protobuf::Message; end
+      class Beacon < ::Protobuf::Message; end
+
+
+      ##
+      # Message Fields
+      #
+      class Server
+        optional :string, :uuid, 1
+        optional :string, :address, 2
+        optional :string, :port, 3
+        optional :int32, :ttl, 4
+        repeated :string, :services, 5
+      end
+
+      class Beacon
+        optional ::Protobuf::Rpc::DynamicDiscovery::BeaconType, :beacon_type, 1
+        optional ::Protobuf::Rpc::DynamicDiscovery::Server, :server, 2
+      end
+
+    end
+
+  end
+
+end
+

data/lib/protobuf/rpc/env.rb

@@ -0,0 +1,58 @@
+module Protobuf
+  module Rpc
+    class Env < Hash
+      # Creates an accessor that simply sets and reads a key in the hash:
+      #
+      #   class Config < Hash
+      #     hash_accessor :app
+      #   end
+      #
+      #   config = Config.new
+      #   config.app = Foo
+      #   config[:app] #=> Foo
+      #
+      #   config[:app] = Bar
+      #   config.app #=> Bar
+      #
+      def self.hash_accessor(*names) #:nodoc:
+        names.each do |name|
+          name_str = name.to_s.freeze
+
+          define_method name do
+            self[name_str]
+          end
+
+          define_method "#{name}=" do |value|
+            self[name_str] = value
+          end
+
+          define_method "#{name}?" do
+            !self[name_str].nil?
+          end
+        end
+      end
+
+      # TODO: Add extra info about the environment (i.e. variables) and other
+      # information that might be useful
+      hash_accessor :client_host,
+                    :encoded_request,
+                    :encoded_response,
+                    :log_signature,
+                    :method_name,
+                    :request,
+                    :request_type,
+                    :response,
+                    :response_type,
+                    :rpc_method,
+                    :rpc_service,
+                    :service_name,
+                    :worker_id
+
+      def initialize(options = {})
+        merge!(options)
+
+        self['worker_id'] = ::Thread.current.object_id.to_s(16)
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/error.rb

@@ -0,0 +1,28 @@
+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) ? Socketrpc::ErrorReason.const_get(error_type) : error_type
+        super message
+      end
+
+      def encode
+        to_response.encode
+      end
+
+      def to_response
+        Socketrpc::Response.new(:error => message, :error_reason => error_type)
+      end
+    end
+  end
+end
+
+require 'protobuf/rpc/error/server_error'
+require 'protobuf/rpc/error/client_error'