protobuf 3.7.0.pre2 → 3.7.0.pre3

data/lib/protobuf/optionable.rb

@@ -10,11 +10,12 @@ module Protobuf
           # are accessing options correctly. We allow simple names in other places for backwards compatibility.
           fail ArgumentError, "must access option using its fully qualified name: #{option.fully_qualified_name.inspect}"
         end
-        if @_optionable_options.try(:key?, name)
-          value = @_optionable_options[name]
-        else
-          value = option.default_value
-        end
+        value =
+          if @_optionable_options.try(:key?, name)
+            @_optionable_options[name]
+          else
+            option.default_value
+          end
         if option.type_class < ::Protobuf::Message
           option.type_class.new(value)
         else
@@ -51,11 +52,10 @@ module Protobuf
         # File options are injected per module, and since a module can be defined more than once,
         # we will get a warning if we try to define optionable_descriptor_class twice.
         if base_class.respond_to?(:optionable_descriptor_class)
-          if base_class.optionable_descriptor_class != block.call
-            fail 'A class is being defined with two different descriptor classes, something is very wrong'
-          else
-            return # Don't define optionable_descriptor_class twice
-          end
+          # Don't define optionable_descriptor_class twice
+          return  if base_class.optionable_descriptor_class == block.call
+
+          fail 'A class is being defined with two different descriptor classes, something is very wrong'
         end
 
         base_class.extend(ClassMethods)

data/lib/protobuf/rpc/buffer.rb

@@ -4,7 +4,7 @@ module Protobuf
 
       attr_accessor :mode, :data, :size
 
-      MODES = [:read, :write]
+      MODES = [:read, :write].freeze
 
       # constantize this so we don't re-initialize the regex every time we need it
       SIZE_REGEX = /^\d+-/
@@ -17,11 +17,12 @@ module Protobuf
       end
 
       def mode=(mode)
-        if MODES.include?(mode)
-          @mode = mode
-        else
-          @mode = :read
-        end
+        @mode =
+          if MODES.include?(mode)
+            mode
+          else
+            :read
+          end
       end
 
       def write(force_mode = true)

data/lib/protobuf/rpc/client.rb

@@ -2,7 +2,6 @@ require 'forwardable'
 require 'protobuf'
 require 'protobuf/logging'
 require 'protobuf/rpc/error'
-require 'protobuf/rpc/connector'
 
 module Protobuf
   module Rpc
@@ -10,7 +9,7 @@ module Protobuf
       extend Forwardable
       include Protobuf::Logging
 
-      def_delegators :@connector, :options, :complete_cb, :success_cb, :failure_cb
+      def_delegators :@connector, :options, :complete_cb, :success_cb, :failure_cb, :send_request
       attr_reader :connector
 
       # Create a new client with default options (defined in ClientConnection)
@@ -28,7 +27,7 @@ module Protobuf
       #
       def initialize(options = {})
         fail "Invalid client configuration. Service must be defined." if options[:service].nil?
-        @connector = Connector.connector_for_client.new(options)
+        @connector = ::Protobuf.connector_type_class.new(options)
         logger.debug { sign_message("Initialized with options: #{options.inspect}") }
       end
 
@@ -134,33 +133,6 @@ module Protobuf
         end
       end
 
-      # Send the request to the service.
-      # This method is usually never called directly
-      # but is invoked by method_missing (see docs above).
-      #
-      #   request = WidgetFindRequest.new
-      #   client = Client.new({
-      #     :service => WidgetService,
-      #     :method => "find",
-      #     :request_type => "WidgetFindRequest",
-      #     :response_type => "WidgetList",
-      #     :request => request
-      #   })
-      #
-      #   client.on_success do |res|
-      #     res.widgets.each{|w| puts w.inspect }
-      #   end
-      #
-      #   client.on_failure do |err|
-      #     puts err.message
-      #   end
-      #
-      #   client.send_request
-      #
-      def send_request
-        @connector.send_request
-      end
-
     end
 
     ActiveSupport.run_load_hooks(:protobuf_rpc_client, Client)

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

@@ -4,7 +4,6 @@ require 'protobuf/rpc/rpc.pb'
 require 'protobuf/rpc/buffer'
 require 'protobuf/rpc/error'
 require 'protobuf/rpc/stat'
-require 'protobuf/rpc/connectors/common'
 
 module Protobuf
   module Rpc
@@ -20,26 +19,113 @@ module Protobuf
         :timeout                 => nil,         # The timeout for the request, also handled by client.rb
         :client_host             => nil,         # The hostname or address of this client
         :first_alive_load_balance => false,      # Do we want to use check_avail frames before request
-      }
+      }.freeze
 
       class Base
         include Protobuf::Logging
 
-        attr_reader :options
-        attr_accessor :success_cb, :failure_cb, :complete_cb
+        attr_reader :options, :error
+        attr_accessor :success_cb, :failure_cb, :complete_cb, :stats
 
         def initialize(options)
           @options = DEFAULT_OPTIONS.merge(options)
           @stats = ::Protobuf::Rpc::Stat.new(:CLIENT)
         end
 
+        def any_callbacks?
+          [@complete_cb, @failure_cb, @success_cb].any?
+        end
+
+        def close_connection
+          fail 'If you inherit a Connector from Base you must implement close_connection'
+        end
+
+        def complete
+          @stats.stop
+          logger.info { @stats.to_s }
+          logger.debug { sign_message('Response proceessing complete') }
+          @complete_cb.call(self) unless @complete_cb.nil?
+        rescue => e
+          logger.error { sign_message('Complete callback error encountered') }
+          log_exception(e)
+          raise
+        end
+
+        def data_callback(data)
+          logger.debug { sign_message('Using data_callback') }
+          @used_data_callback = true
+          @data = data
+        end
+
+        # All failures should be routed through this method.
+        #
+        # @param [Symbol] code The code we're using (see ::Protobuf::Socketrpc::ErrorReason)
+        # @param [String] message The error message
+        def failure(code, message)
+          @error = ClientError.new
+          @error.code = ::Protobuf::Socketrpc::ErrorReason.fetch(code)
+          @error.message = message
+          logger.debug { sign_message("Server failed request (invoking on_failure): #{@error.inspect}") }
+
+          @failure_cb.call(@error) unless @failure_cb.nil?
+        rescue => e
+          logger.error { sign_message("Failure callback error encountered") }
+          log_exception(e)
+          raise
+        ensure
+          complete
+        end
+
         def first_alive_load_balance?
           ENV.key?("PB_FIRST_ALIVE_LOAD_BALANCE") ||
             options[:first_alive_load_balance]
         end
 
-        def send_request
-          fail 'If you inherit a Connector from Base you must implement send_request'
+        def initialize_stats
+          @stats = ::Protobuf::Rpc::Stat.new(:CLIENT)
+          @stats.server = [@options[:port], @options[:host]]
+          @stats.service = @options[:service].name
+          @stats.method_name = @options[:method].to_s
+        rescue => ex
+          log_exception(ex)
+          failure(:RPC_ERROR, "Invalid stats configuration. #{ex.message}")
+        end
+
+        def log_signature
+          @_log_signature ||= "[client-#{self.class}]"
+        end
+
+        def parse_response
+          # Close up the connection as we no longer need it
+          close_connection
+
+          logger.debug { sign_message("Parsing response from server (connection closed)") }
+
+          # Parse out the raw response
+          @stats.response_size = @response_data.size unless @response_data.nil?
+          response_wrapper = ::Protobuf::Socketrpc::Response.decode(@response_data)
+
+          # Determine success or failure based on parsed data
+          if response_wrapper.field?(:error_reason)
+            logger.debug { sign_message("Error response parsed") }
+
+            # fail the call if we already know the client is failed
+            # (don't try to parse out the response payload)
+            failure(response_wrapper.error_reason, response_wrapper.error)
+          else
+            logger.debug { sign_message("Successful response parsed") }
+
+            # Ensure client_response is an instance
+            parsed = @options[:response_type].decode(response_wrapper.response_proto.to_s)
+
+            if parsed.nil? && !response_wrapper.field?(:error_reason)
+              failure(:BAD_RESPONSE_PROTO, 'Unable to parse response from server')
+            else
+              verify_callbacks
+              succeed(parsed)
+              return @data if @used_data_callback
+            end
+          end
         end
 
         def ping_port
@@ -49,6 +135,82 @@ module Protobuf
         def ping_port_enabled?
           ENV.key?("PB_RPC_PING_PORT")
         end
+
+        def request_bytes
+          validate_request_type!
+          fields = { :service_name => @options[:service].name,
+                     :method_name => @options[:method].to_s,
+                     :request_proto => @options[:request],
+                     :caller => request_caller }
+
+          return ::Protobuf::Socketrpc::Request.encode(fields)
+        rescue => e
+          failure(:INVALID_REQUEST_PROTO, "Could not set request proto: #{e.message}")
+        end
+
+        def request_caller
+          @options[:client_host] || ::Protobuf.client_host
+        end
+
+        def send_request
+          fail 'If you inherit a Connector from Base you must implement send_request'
+        end
+
+        def setup_connection
+          initialize_stats
+          @request_data = request_bytes
+          @stats.request_size = @request_data.size
+        end
+
+        def succeed(response)
+          logger.debug { sign_message("Server succeeded request (invoking on_success)") }
+          @success_cb.call(response) unless @success_cb.nil?
+        rescue => e
+          logger.error { sign_message("Success callback error encountered") }
+          log_exception(e)
+          failure(:RPC_ERROR, "An exception occurred while calling on_success: #{e.message}")
+        ensure
+          complete
+        end
+
+        def timeout
+          if options[:timeout]
+            options[:timeout]
+          else
+            300 # seconds
+          end
+        end
+
+        # Wrap the given block in a timeout of the configured number of seconds.
+        #
+        def timeout_wrap(&block)
+          ::Timeout.timeout(timeout, &block)
+        rescue ::Timeout::Error
+          failure(:RPC_FAILED, "The server took longer than #{timeout} seconds to respond")
+        end
+
+        def validate_request_type!
+          unless @options[:request].class == @options[:request_type]
+            expected = @options[:request_type].name
+            actual = @options[:request].class.name
+            failure(:INVALID_REQUEST_PROTO, "Expected request type to be type of #{expected}, got #{actual} instead")
+          end
+        end
+
+        def verify_callbacks
+          unless any_callbacks?
+            logger.debug { sign_message("No callbacks set, using data_callback") }
+            @success_cb = @failure_cb = method(:data_callback)
+          end
+        end
+
+        def verify_options!
+          # Verify the options that are necessary and merge them in
+          [:service, :method, :host, :port].each do |opt|
+            failure(:RPC_ERROR, "Invalid client connection configuration. #{opt} must be a defined option.") if @options[opt].nil?
+          end
+        end
+
       end
     end
   end

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

@@ -29,9 +29,9 @@ module Protobuf
         def timeout
           @timeout ||= begin
             if ::ENV.key?("PB_RPC_PING_PORT_TIMEOUT")
-              ::ENV["PB_RPC_PING_PORT_TIMEOUT"].to_i
+              ::ENV["PB_RPC_PING_PORT_TIMEOUT"].to_f / 1000
             else
-              5 # 5 seconds
+              0.2 # 200 ms
             end
           end
         end

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

@@ -4,7 +4,6 @@ module Protobuf
   module Rpc
     module Connectors
       class Socket < Base
-        include Protobuf::Rpc::Connectors::Common
         include Protobuf::Logging
 
         def send_request
@@ -39,6 +38,12 @@ module Protobuf
           @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
 

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

@@ -14,7 +14,6 @@ module Protobuf
         ##
         # Included Modules
         #
-        include Protobuf::Rpc::Connectors::Common
         include Protobuf::Logging
 
         ##
@@ -271,7 +270,7 @@ module Protobuf
         def zmq_eagain_error_check(return_code, source)
           return if ::ZMQ::Util.resultcode_ok?(return_code || -1)
 
-          if ::ZMQ::Util.errno == ::ZMQ::EAGAIN
+          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}".
 

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

@@ -3,11 +3,12 @@
 ##
 # 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/error.rb

@@ -9,7 +9,7 @@ module Protobuf
       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
+        @error_type = error_type.is_a?(String) ? ::Protobuf::Socketrpc::ErrorReason.const_get(error_type) : error_type
         super message
       end
 
@@ -18,7 +18,7 @@ module Protobuf
       end
 
       def to_response
-        Socketrpc::Response.new(:error => message, :error_reason => error_type)
+        ::Protobuf::Socketrpc::Response.new(:error => message, :error_reason => error_type)
       end
     end
   end

data/lib/protobuf/rpc/middleware/exception_handler.rb

@@ -11,6 +11,10 @@ module Protobuf
         end
 
         def call(env)
+          dup._call(env)
+        end
+
+        def _call(env)
           app.call(env)
         rescue => exception
           log_exception(exception)

data/lib/protobuf/rpc/middleware/logger.rb

@@ -8,6 +8,10 @@ module Protobuf
 
         # TODO: Figure out how to control when logs are flushed
         def call(env)
+          dup._call(env)
+        end
+
+        def _call(env)
           instrumenter.start
           instrumenter.flush(env) # Log request stats
 

data/lib/protobuf/rpc/middleware/request_decoder.rb

@@ -11,8 +11,13 @@ module Protobuf
         end
 
         def call(env)
+          dup._call(env)
+        end
+
+        def _call(env)
           @env = env
 
+          logger.debug { sign_message("Decoding request: #{env.encoded_request}") }
           env.service_name = service_name
           env.method_name = method_name
           env.request = request
@@ -33,22 +38,15 @@ module Protobuf
         private
 
         def method_name
-          @method_name ||= begin
-            method_name = request_wrapper.method_name.underscore.to_sym
-
-            unless service.rpc_method?(method_name)
-              fail MethodNotFound, "#{service.name}##{method_name} is not a defined RPC method."
-            end
+          return @method_name unless @method_name.nil?
 
-            method_name
-          end
+          @method_name = request_wrapper.method_name.underscore.to_sym
+          fail MethodNotFound, "#{service.name}##{@method_name} is not a defined RPC method." unless service.rpc_method?(@method_name)
+          @method_name
         end
 
         def request
-          @request ||= begin
-            data = request_wrapper.request_proto
-            rpc_method.request_type.decode(data)
-          end
+          @request ||= rpc_method.request_type.decode(request_wrapper.request_proto)
         rescue => exception
           raise BadRequestData, "Unable to decode request: #{exception.message}"
         end
@@ -56,10 +54,7 @@ module Protobuf
         # Decode the incoming request object into our expected request object
         #
         def request_wrapper
-          @request_wrapper ||= begin
-            logger.debug { sign_message("Decoding request: #{env.encoded_request}") }
-            Socketrpc::Request.decode(env.encoded_request)
-          end
+          @request_wrapper ||= ::Protobuf::Socketrpc::Request.decode(env.encoded_request)
         rescue => exception
           raise BadRequestData, "Unable to decode request: #{exception.message}"
         end

data/lib/protobuf/rpc/middleware/response_encoder.rb

@@ -11,6 +11,10 @@ module Protobuf
         end
 
         def call(env)
+          dup._call(env)
+        end
+
+        def _call(env)
           @env = app.call(env)
 
           env.response = response
@@ -41,32 +45,23 @@ module Protobuf
         # Prod the object to see if we can produce a proto object as a response
         # candidate. Validate the candidate protos.
         def response
-          @response ||= begin
-                          candidate = env.response
-                          case
-                          when candidate.is_a?(Message) then
-                            validate!(candidate)
-                          when candidate.respond_to?(:to_proto) then
-                            validate!(candidate.to_proto)
-                          when candidate.respond_to?(:to_hash) then
-                            env.response_type.new(candidate.to_hash)
-                          when candidate.is_a?(PbError) then
-                            candidate
-                          else
-                            validate!(candidate)
-                          end
-                        end
+          return @response unless @response.nil?
+
+          candidate = env.response
+          return @response = validate!(candidate) if candidate.is_a?(Message)
+          return @response = validate!(candidate.to_proto) if candidate.respond_to?(:to_proto)
+          return @response = env.response_type.new(candidate.to_hash) if candidate.respond_to?(:to_hash)
+          return @response = candidate if candidate.is_a?(PbError)
+
+          @response = validate!(candidate)
         end
 
         # Ensure that the response candidate we've been given is of the type
         # we expect so that deserialization on the client side works.
         #
         def validate!(candidate)
-          actual = candidate.class
-          expected = env.response_type
-
-          if expected != actual
-            fail BadResponseProto, "Expected response to be of type #{expected.name} but was #{actual.name}"
+          if candidate.class != env.response_type
+            fail BadResponseProto, "Expected response to be of type #{env.response_type.name} but was #{candidate.class.name}"
           end
 
           candidate
@@ -76,10 +71,10 @@ module Protobuf
         # it up so that it's in the correct spot in the response wrapper
         #
         def wrapped_response
-          if response.is_a?(Protobuf::Rpc::PbError)
-            Socketrpc::Response.new(:error => response.message, :error_reason => response.error_type)
+          if response.is_a?(::Protobuf::Rpc::PbError)
+            ::Protobuf::Socketrpc::Response.new(:error => response.message, :error_reason => response.error_type)
           else
-            Socketrpc::Response.new(:response_proto => response.encode)
+            ::Protobuf::Socketrpc::Response.new(:response_proto => response.encode)
           end
         end
       end

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

@@ -3,10 +3,11 @@
 ##
 # This file is auto-generated. DO NOT EDIT!
 #
-require 'protobuf/message'
+require 'protobuf'
 
 module Protobuf
   module Socketrpc
+    ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions }
 
     ##
     # Enum Classes

data/lib/protobuf/rpc/rpc_method.rb

@@ -0,0 +1,16 @@
+module Protobuf
+  module Rpc
+    class RpcMethod
+      ::Protobuf::Optionable.inject(self, false) { ::Google::Protobuf::MethodOptions }
+
+      attr_reader :method, :request_type, :response_type
+
+      def initialize(method, request_type, response_type, &options_block)
+        @method = method
+        @request_type = request_type
+        @response_type = response_type
+        instance_eval(&options_block) if options_block
+      end
+    end
+  end
+end

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

@@ -18,7 +18,7 @@ module Protobuf
         public
 
         attr_reader :running
-        alias_method :running?, :running
+        alias :running? running
 
         def initialize(options)
           self.running = false
@@ -38,7 +38,7 @@ module Protobuf
 
         def cleanup?
           # every `threshold` connections run a cleanup routine after closing the response
-          threads.size > 0 && threads.size % threshold == 0
+          !threads.empty? && threads.size % threshold == 0
         end
 
         def cleanup_threads
@@ -102,9 +102,9 @@ module Protobuf
                     end
                   end
                 end
-              else
+              elsif threads.size > 1
                 # Run a cleanup if select times out while waiting
-                cleanup_threads if threads.size > 1
+                cleanup_threads
               end
             end
           ensure

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

@@ -36,3 +36,11 @@ module Protobuf
     end
   end
 end
+
+module Protobuf
+  module Rpc
+    module Servers # bad file namespacing
+      SocketRunner = ::Protobuf::Rpc::SocketRunner
+    end
+  end
+end

data/lib/protobuf/rpc/servers/zmq/broker.rb

@@ -107,11 +107,12 @@ module Protobuf
         end
 
         def init_zmq_context
-          if inproc?
-            @zmq_context = @server.zmq_context
-          else
-            @zmq_context = ZMQ::Context.new
-          end
+          @zmq_context =
+            if inproc?
+              @server.zmq_context
+            else
+              ZMQ::Context.new
+            end
         end
 
         def inproc?
@@ -146,7 +147,7 @@ module Protobuf
               write_to_frontend([address, ::Protobuf::Rpc::Zmq::EMPTY_STRING, ::Protobuf::Rpc::Zmq::NO_WORKERS_AVAILABLE])
             end
           else
-            if @idle_workers.empty?
+            if @idle_workers.empty? # rubocop:disable Style/IfInsideElse
               local_queue << [address, ::Protobuf::Rpc::Zmq::EMPTY_STRING, message].concat(frames)
             else
               write_to_backend([@idle_workers.shift, ::Protobuf::Rpc::Zmq::EMPTY_STRING].concat([address, ::Protobuf::Rpc::Zmq::EMPTY_STRING, message]).concat(frames))