protobuf 2.7.12 → 2.8.0.beta1

data/lib/protobuf/field/float_field.rb

@@ -4,6 +4,10 @@ module Protobuf
   module Field
     class FloatField < BaseField
       def self.default; 0.0; end
+      def self.max;  1.0/0; end
+      def self.min; -1.0/0; end
+      def max;  1.0/0; end
+      def min; -1.0/0; end
 
       def wire_type
         WireType::FIXED32
@@ -18,7 +22,7 @@ module Protobuf
       end
 
       def acceptable?(val)
-        val.respond_to?(:to_f)
+        (val > min || val < max) rescue false
       end
     end
   end

data/lib/protobuf/field/string_field.rb

@@ -6,18 +6,17 @@ module Protobuf
       ENCODING = 'UTF-8'.freeze
 
       def decode(bytes)
-        bytes_to_decode = bytes.dup
-        bytes_to_decode.force_encoding(::Protobuf::Field::StringField::ENCODING)
-        bytes_to_decode
+        bytes.force_encoding(::Protobuf::Field::StringField::ENCODING)
+        bytes
       end
 
       def encode(value)
-        value_to_encode = value.dup
-        value_to_encode.encode!(::Protobuf::Field::StringField::ENCODING, :invalid => :replace, :undef => :replace, :replace => "")
-        value_to_encode.force_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
+        # TODO: make replace character configurable?
+        value.encode!(::Protobuf::Field::StringField::ENCODING, :invalid => :replace, :undef => :replace, :replace => "")
+        value.force_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
 
-        string_size = ::Protobuf::Field::VarintField.encode(value_to_encode.size)
-        string_size << value_to_encode
+        string_size = ::Protobuf::Field::VarintField.encode(value.size)
+        string_size << value
       end
     end
   end

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

@@ -17,7 +17,7 @@ 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        => 15,            # The default timeout for the request, also handled by client.rb
         :client_host    => nil            # The hostname or address of this client
       }
 

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

@@ -1,23 +1,38 @@
 require 'protobuf/rpc/connectors/base'
+require 'protobuf/rpc/service_directory'
 
 module Protobuf
   module Rpc
     module Connectors
       class Zmq < Base
+
+        ##
+        # Included Modules
+        #
+
         include Protobuf::Rpc::Connectors::Common
         include Protobuf::Logger::LogMethods
 
+        ##
+        # Class Constants
+        #
+
+        CLIENT_RETRIES = (ENV['PB_CLIENT_RETRIES'] || 3)
+
+        ##
+        # Instance methods
+        #
+
+        # 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
-          timeout_wrap do
-            setup_connection
-            connect_to_rpc_server
-            post_init
-            read_response
-          end
+          setup_connection
+          poll_send_data
         ensure
-          @socket.close if @socket
-          @zmq_context.terminate if @zmq_context
-          @zmq_context = nil
+          close_connection
         end
 
         def log_signature
@@ -26,45 +41,158 @@ module Protobuf
 
         private
 
+        ##
+        # Private Instance methods
+        #
+
         def close_connection
-          return if @error
-          zmq_error_check(@socket.close)
-          zmq_error_check(@zmq_context.terminate)
-          log_debug { sign_message("Connector closed")  }
+          socket_close
+          zmq_context_terminate
         end
 
+        # Establish a request socket connection to the remote rpc_server.
+        # Set the socket option LINGER to 0 so that we don't wait
+        # for queued messages to be accepted when the socket/context are
+        # asked to close/terminate.
+        #
         def connect_to_rpc_server
-          return if @error
-          log_debug { sign_message("Establishing connection: #{options[:host]}:#{options[:port]}") }
-          @zmq_context = ::ZMQ::Context.new
-          @socket = @zmq_context.socket(::ZMQ::REQ)
-          zmq_error_check(@socket.connect("tcp://#{options[:host]}:#{options[:port]}"))
-          log_debug { sign_message("Connection established #{options[:host]}:#{options[:port]}") }
+          return if error?
+
+          server_uri = lookup_server_uri
+          log_debug { sign_message("Establishing connection: #{server_uri}") }
+          socket.setsockopt(::ZMQ::LINGER, 0)
+          zmq_error_check(socket.connect(server_uri), :socket_connect)
+          zmq_error_check(poller.register_readable(socket), :poller_register_readable)
+          log_debug { sign_message("Connection established to #{server_uri}") }
         end
 
-        # Method to determine error state, must be used with Connector api
+        # Method to determine error state, must be used with Connector API.
+        #
         def error?
-          !!@error
+          !! @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
+          if service_directory.running?
+            listing = service_directory.lookup(service)
+            host, port = listing.address, listing.port if listing
+          end
+
+          host, port = options[:host], options[:port] unless host && port
+
+          "tcp://#{host}:#{port}"
+        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 poll_send_data
+          return if error?
+
+          poll_timeout = (options[:timeout].to_f / CLIENT_RETRIES.to_f) * 1000
+
+          CLIENT_RETRIES.times do |n|
+            connect_to_rpc_server
+            log_debug { sign_message("Sending Request (attempt #{n + 1}, #{socket})") }
+            send_data
+            log_debug { sign_message("Request sending complete (attempt #{n + 1}, #{socket})") }
+
+            if poller.poll(poll_timeout) == 1
+              read_response
+              return
+            else
+              close_connection
+            end
+          end
+
+          fail(:RPC_FAILED, "The server took longer than #{options[:timeout]} seconds to respond")
         end
 
+        def poller
+          @poller ||= ::ZMQ::Poller.new
+        end
+
+        # Read the string response from the available readable. This will be
+        # the current @socket. Calls `parse_response` to invoke the success or
+        # failed callbacks, depending on the state of the communication
+        # and response data.
+        #
         def read_response
-          return if @error
+          return if error?
+
           @response_data = ''
-          zmq_error_check(@socket.recv_string(@response_data))
+          zmq_error_check(socket.recv_string(@response_data), :socket_recv_string)
+
           parse_response
         end
 
+        # Send the request data to the remote rpc_server.
+        #
         def send_data
-          return if @error
-          log_debug { sign_message("Sending Request: #{@request_data}") }
+          return if error?
+
           @stats.request_size = @request_data.size
-          zmq_error_check(@socket.send_string(@request_data))
-          log_debug { sign_message("write closed") }
+          zmq_error_check(socket.send_string(@request_data), :socket_send_string)
+        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
+
+        # Setup a ZMQ request socket in the current zmq context.
+        #
+        def socket
+          @socket ||= zmq_context.socket(::ZMQ::REQ)
         end
 
-        def zmq_error_check(return_code)
-          raise "Last API call failed at #{caller(1)}" unless return_code >= 0
+        def socket_close
+          if socket
+            log_debug { sign_message("Closing Socket")  }
+            zmq_error_check(socket.close, :socket_close)
+            log_debug { sign_message("Socket closed")  }
+            @socket = nil
+          end
+        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
+          @zmq_context ||= ::ZMQ::Context.new
+        end
+
+        # Terminate the zmq_context (if any).
+        #
+        def zmq_context_terminate
+          log_debug { sign_message("Terminating ZMQ Context")  }
+          @zmq_context.try(:terminate)
+          @zmq_context = nil
+          log_debug { sign_message("ZMQ Context terminated")  }
         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}".
+
+            #{caller(1).join($/)}
+            ERROR
+          end
+        end
+
       end
     end
   end

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

@@ -0,0 +1,49 @@
+##
+# 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 ::Protobuf::Field::StringField, :uuid, 1
+        optional ::Protobuf::Field::StringField, :address, 2
+        optional ::Protobuf::Field::StringField, :port, 3
+        optional ::Protobuf::Field::Int32Field, :ttl, 4
+        repeated ::Protobuf::Field::StringField, :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/error/client_error.rb

@@ -2,30 +2,30 @@ require 'protobuf/rpc/error'
 
 module Protobuf
   module Rpc
-    
+
     class InvalidRequestProto < PbError
       def initialize(message='Invalid request type given')
         super message, 'INVALID_REQUEST_PROTO'
       end
     end
-    
+
     class BadResponseProto < PbError
       def initialize(message='Bad response type from server')
         super message, 'BAD_RESPONSE_PROTO'
       end
     end
-    
+
     class UnkownHost < PbError
       def initialize(message='Unknown host or port')
         super message, 'UNKNOWN_HOST'
       end
     end
-    
+
     class IOError < PbError
       def initialize(message='IO Error occurred')
         super message, 'IO_ERROR'
       end
     end
-    
+
   end
 end

data/lib/protobuf/rpc/error/server_error.rb

@@ -2,42 +2,42 @@ require 'protobuf/rpc/rpc.pb'
 
 module Protobuf
   module Rpc
-    
+
     class BadRequestData < PbError
       def initialize message='Unable to parse request'
         super message, 'BAD_REQUEST_DATA'
       end
     end
-    
+
     class BadRequestProto < PbError
       def initialize message='Request is of wrong type'
         super message, 'BAD_REQUEST_PROTO'
       end
     end
-    
+
     class ServiceNotFound < PbError
       def initialize message='Service class not found'
         super message, 'SERVICE_NOT_FOUND'
       end
     end
-    
+
     class MethodNotFound < PbError
       def initialize message='Service method not found'
         super message, 'METHOD_NOT_FOUND'
       end
     end
-    
+
     class RpcError < PbError
       def initialize message='RPC exception occurred'
         super message, 'RPC_ERROR'
       end
     end
-    
+
     class RpcFailed < PbError
       def initialize message='RPC failed'
         super message, 'RPC_FAILED'
       end
     end
-    
+
   end
 end

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

@@ -4,22 +4,13 @@
 require 'protobuf/message'
 
 module Protobuf
+
   module Socketrpc
+  
     ##
     # Enum Classes
     #
-    class ErrorReason < ::Protobuf::Enum; end
-    
-    ##
-    # Message Classes
-    #
-    class Request < ::Protobuf::Message; end
-    class Response < ::Protobuf::Message; end
-    
-    ##
-    # Enum Values
-    #
-    class ErrorReason
+    class ErrorReason < ::Protobuf::Enum
       define :BAD_REQUEST_DATA, 0
       define :BAD_REQUEST_PROTO, 1
       define :SERVICE_NOT_FOUND, 2
@@ -32,6 +23,13 @@ module Protobuf
       define :IO_ERROR, 9
     end
     
+    
+    ##
+    # Message Classes
+    #
+    class Request < ::Protobuf::Message; end
+    class Response < ::Protobuf::Message; end
+    
     ##
     # Message Fields
     #
@@ -49,5 +47,8 @@ module Protobuf
       optional ::Protobuf::Socketrpc::ErrorReason, :error_reason, 4
     end
     
+    
   end
+  
 end
+