protobuf 2.7.11-java → 2.8.0.beta1-java

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
+

data/lib/protobuf/rpc/servers/evented_runner.rb

@@ -2,22 +2,27 @@ module Protobuf
   module Rpc
     class EventedRunner
 
-      def self.register_signals
-        # Noop
+      def initialize(options)
+        @options = options
       end
 
-      def self.run(options)
+      def run
         # Startup and run the rpc server
         ::EventMachine.schedule do
-          ::EventMachine.start_server(options[:host], options[:port], ::Protobuf::Rpc::Evented::Server)
+          ::EventMachine.start_server(
+            @options[:host],
+            @options[:port],
+            ::Protobuf::Rpc::Evented::Server
+          )
         end
 
         # Join or start the reactor
-				yield if block_given?
+        yield if block_given?
+
         ::EM.reactor_running? ? ::EM.reactor_thread.join : ::EM.run
       end
 
-      def self.stop
+      def stop
         ::EventMachine.stop_event_loop if ::EventMachine.reactor_running?
       end
 

data/lib/protobuf/rpc/servers/socket/server.rb

@@ -11,12 +11,16 @@ module Protobuf
 
         AUTO_COLLECT_TIMEOUT = 5 # seconds
 
-        def self.cleanup?
+        def initialize(options)
+          @options = options
+        end
+
+        def cleanup?
           # every 10 connections run a cleanup routine after closing the response
           @threads.size > (@threshold - 1) && (@threads.size % @threshold) == 0
         end
 
-        def self.cleanup_threads
+        def cleanup_threads
           log_debug { sign_message("Thread cleanup - #{@threads.size} - start") }
 
           @threads = @threads.select do |t|
@@ -32,11 +36,11 @@ module Protobuf
           log_debug { sign_message("Thread cleanup - #{@threads.size} - complete") }
         end
 
-        def self.log_signature
+        def log_signature
           @_log_signature ||= "server-#{self.class.name}"
         end
 
-        def self.new_worker(socket)
+        def new_worker(socket)
           Thread.new(socket) do |sock|
             ::Protobuf::Rpc::Socket::Worker.new(sock) do |s|
               s.close
@@ -44,12 +48,12 @@ module Protobuf
           end
         end
 
-        def self.run(options = {})
+        def run
           log_debug { sign_message("Run") }
-          host = options[:host]
-          port = options[:port]
-          backlog = options[:backlog]
-          @threshold = options[:threshold]
+          host = @options[:host]
+          port = @options[:port]
+          backlog = @options[:backlog]
+          @threshold = @options[:threshold]
 
           @threads = []
           @server = ::TCPServer.new(host, port)
@@ -62,8 +66,9 @@ module Protobuf
 
           while running?
             log_debug { sign_message("Waiting for connections") }
+            ready_cnxns = IO.select(@listen_fds, [], [], AUTO_COLLECT_TIMEOUT) rescue nil
 
-            if ready_cnxns = IO.select(@listen_fds, [], [], AUTO_COLLECT_TIMEOUT)
+            if ready_cnxns
               cnxns = ready_cnxns.first
               cnxns.each do |client|
                 case
@@ -96,16 +101,15 @@ module Protobuf
           raise #if running?
         end
 
-        def self.running?
-          @running
+        def running?
+          !!@running
         end
 
-        def self.stop
+        def stop
           @running = false
-          @server.close if @server
+          @server.try(:close)
         end
       end
-
     end
   end
 end