protobuf 3.3.6 → 3.4.0

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

@@ -26,7 +26,7 @@ module Protobuf
 
           loop do
             process_local_queue
-            rc = @poller.poll(500)
+            rc = @poller.poll(broker_polling_milliseconds)
 
             # The server was shutdown and no requests are pending
             break if rc == 0 && !running? && @server.workers.empty?
@@ -51,11 +51,15 @@ module Protobuf
           @backend_poll_weight ||= [ENV["PB_ZMQ_SERVER_BACKEND_POLL_WEIGHT"].to_i, 1].max
         end
 
+        def broker_polling_milliseconds
+          @broker_polling_milliseconds ||= [ENV["PB_ZMQ_BROKER_POLLING_MILLISECONDS"].to_i, 500].max
+        end
+
         def check_and_process_backend
           readables_include_backend = @poller.readables.include?(@backend_socket)
           message_count_read_from_backend = 0
 
-          while readables_include_backend && message_count_read_from_backend < backend_poll_weight do
+          while readables_include_backend && message_count_read_from_backend < backend_poll_weight
             message_count_read_from_backend += 1
             process_backend
             @poller.poll_nonblock
@@ -67,7 +71,7 @@ module Protobuf
           readables_include_frontend = @poller.readables.include?(@frontend_socket)
           message_count_read_from_frontend = 0
 
-          while readables_include_frontend && message_count_read_from_frontend < frontend_poll_weight do
+          while readables_include_frontend && message_count_read_from_frontend < frontend_poll_weight
             message_count_read_from_frontend += 1
             process_frontend
             break unless local_queue_available? # no need to read frontend just to throw away messages, will prioritize backend when full
@@ -121,7 +125,7 @@ module Protobuf
         end
 
         def process_backend
-          worker, ignore, *frames = read_from_backend
+          worker, _ignore, *frames = read_from_backend
 
           @idle_workers << worker
 
@@ -141,9 +145,9 @@ module Protobuf
             end
           else
             if @idle_workers.empty?
-              local_queue << [address, ::Protobuf::Rpc::Zmq::EMPTY_STRING, message ].concat(frames)
+              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))
+              write_to_backend([@idle_workers.shift, ::Protobuf::Rpc::Zmq::EMPTY_STRING].concat([address, ::Protobuf::Rpc::Zmq::EMPTY_STRING, message]).concat(frames))
             end
           end
         end

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

@@ -62,15 +62,10 @@ module Protobuf
         end
 
         def beacon_port
-          unless @beacon_port
-            unless port = options[:beacon_port]
-              port = ::Protobuf::Rpc::ServiceDirectory.port
-            end
-
-            @beacon_port = port.to_i
-          end
-
-          @beacon_port
+          @beacon_port ||= options.fetch(
+            :beacon_port,
+            ::Protobuf::Rpc::ServiceDirectory.port,
+          ).to_i
         end
 
         def beacon_uri
@@ -84,7 +79,7 @@ module Protobuf
         def broadcast_flatline
           flatline = ::Protobuf::Rpc::DynamicDiscovery::Beacon.new(
             :beacon_type => ::Protobuf::Rpc::DynamicDiscovery::BeaconType::FLATLINE,
-            :server => self.to_proto
+            :server => to_proto,
           )
 
           @beacon_socket.send(flatline.encode, 0)
@@ -95,7 +90,7 @@ module Protobuf
 
           heartbeat = ::Protobuf::Rpc::DynamicDiscovery::Beacon.new(
             :beacon_type => ::Protobuf::Rpc::DynamicDiscovery::BeaconType::HEARTBEAT,
-            :server => self.to_proto
+            :server => to_proto,
           )
 
           @beacon_socket.send(heartbeat.encode, 0)
@@ -129,7 +124,7 @@ module Protobuf
         end
 
         def inproc?
-          !!self.options[:zmq_inproc]
+          !!options[:zmq_inproc]
         end
 
         def maintenance_timeout
@@ -167,7 +162,7 @@ module Protobuf
           @last_reaping = Time.now.to_i
 
           @workers.keep_if do |worker|
-            worker.alive? or worker.join && false
+            worker.alive? || worker.join && false
           end
         end
 
@@ -221,10 +216,6 @@ module Protobuf
           @last_reaping = @last_beacon = @timeout = nil
         end
 
-        def total_workers
-          @total_workers ||= [@options[:threads].to_i, 1].max
-        end
-
         def timeout
           if @timeout.nil?
             @timeout = 0
@@ -233,13 +224,17 @@ module Protobuf
           end
         end
 
+        def total_workers
+          @total_workers ||= [@options[:threads].to_i, 1].max
+        end
+
         def to_proto
           @proto ||= ::Protobuf::Rpc::DynamicDiscovery::Server.new(
             :uuid => uuid,
             :address => frontend_ip,
             :port => frontend_port.to_s,
             :ttl => (beacon_interval * 1.5).ceil,
-            :services => ::Protobuf::Rpc::Service.implemented_services
+            :services => ::Protobuf::Rpc::Service.implemented_services,
           )
         end
 
@@ -256,14 +251,13 @@ module Protobuf
               start_missing_workers
             end
 
-            if broadcast_heartbeat?
-              if all_workers_busy? && options[:broadcast_busy]
-                broadcast_flatline
-              else
-                broadcast_heartbeat
-              end
-            end
+            next unless broadcast_heartbeat?
 
+            if options[:broadcast_busy] && all_workers_busy?
+              broadcast_flatline
+            else
+              broadcast_heartbeat
+            end
           end
         end
 
@@ -301,7 +295,7 @@ module Protobuf
             begin
               ::Protobuf::Rpc::Zmq::Worker.new(server).run
             rescue => e
-              message = "Worker failed: #{e.inspect}\n #{e.backtrace.join($/)}"
+              message = "Worker failed: #{e.inspect}\n #{e.backtrace.join($INPUT_RECORD_SEPARATOR)}"
               $stderr.puts(message)
               logger.error { message }
             end

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

@@ -19,13 +19,13 @@ module Protobuf
         end
 
         def zmq_error_check(return_code, source = nil)
-          unless ::ZMQ::Util.resultcode_ok?(return_code)
-            raise <<-ERROR
-            Last ZMQ API call #{source ? "to #{source}" : ""} failed with "#{::ZMQ::Util.error_string}".
+          return if ::ZMQ::Util.resultcode_ok?(return_code)
 
-            #{caller(1).join($/)}
-            ERROR
-          end
+          fail <<-ERROR
+          Last ZMQ API call #{source ? "to #{source}" : ''} failed with "#{::ZMQ::Util.error_string}".
+
+          #{caller(1).join($INPUT_RECORD_SEPARATOR)}
+          ERROR
         end
 
         def log_signature
@@ -38,7 +38,7 @@ module Protobuf
         end
 
         def resolve_ip(hostname)
-          ::Resolv.getaddresses(hostname).detect do |address|
+          ::Resolv.getaddresses(hostname).find do |address|
             address =~ ADDRESS_MATCH
           end
         end

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

@@ -46,13 +46,11 @@ module Protobuf
           loop do
             rc = poller.poll(500)
 
-            # The server was shutdown and no requests are pending
-            break if rc == 0 && !running?
-
-            # Something went wrong
-            break if rc == -1
-
-            if rc > 0
+            if rc == 0 && !running?
+              break # The server was shutdown and no requests are pending
+            elsif rc == -1
+              break # Something went wrong
+            elsif rc > 0
               ::Thread.current[:busy] = true
               process_request
               ::Thread.current[:busy] = false

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

@@ -1,4 +1,5 @@
 require 'ostruct'
+require 'thread'
 
 module Protobuf
   module Rpc
@@ -12,9 +13,8 @@ module Protobuf
                    when options.respond_to?(:to_hash) then
                      options.to_hash
                    else
-                     raise "Cannot parser Zmq Server - server options"
+                     fail "Cannot parser Zmq Server - server options"
                    end
-
       end
 
       def run
@@ -36,6 +36,17 @@ module Protobuf
       private
 
       def register_signals
+        trap(:TRAP) do
+          ::Thread.list.each do |thread|
+            logger.info do
+              <<-THREAD_TRACE
+                #{thread.inspect}:
+                  #{thread.backtrace.join($INPUT_RECORD_SEPARATOR)}"
+              THREAD_TRACE
+            end
+          end
+        end
+
         trap(:TTIN) do
           @server.add_worker
           logger.info { "Increased worker size to: #{@server.total_workers}" }
@@ -43,7 +54,7 @@ module Protobuf
 
         trap(:TTOU) do
           logger.info { "Current worker size: #{@server.workers.size}" }
-          logger.info { "Current worker size: #{@server.busy_worker_count}" }
+          logger.info { "Current busy worker size: #{@server.busy_worker_count}" }
         end
       end
     end

data/lib/protobuf/rpc/service.rb

@@ -54,19 +54,19 @@ module Protobuf
       # The host location of the service.
       #
       def self.host
-        @_host ||= DEFAULT_HOST
+        @host ||= DEFAULT_HOST
       end
 
       # The host location setter.
       #
-      def self.host=(new_host)
-        @_host = new_host
+      class << self
+        attr_writer :host
       end
 
       # An array of defined service classes that contain implementation
       # code
       def self.implemented_services
-        classes = (self.subclasses || []).select do |subclass|
+        classes = (subclasses || []).select do |subclass|
           subclass.rpcs.any? do |(name, _)|
             subclass.method_defined? name
           end
@@ -88,13 +88,13 @@ module Protobuf
       # The port of the service on the destination server.
       #
       def self.port
-        @_port ||= DEFAULT_PORT
+        @port ||= DEFAULT_PORT
       end
 
       # The port location setter.
       #
-      def self.port=(new_port)
-        @_port = new_port
+      class << self
+        attr_writer :port
       end
 
       # Define an rpc method with the given request and response types.
@@ -108,7 +108,7 @@ module Protobuf
       # Hash containing the set of methods defined via `rpc`.
       #
       def self.rpcs
-        @_rpcs ||= {}
+        @rpcs ||= {}
       end
 
       # Check if the given method name is a known rpc endpoint.
@@ -126,13 +126,13 @@ module Protobuf
       # is why we wrap the method call).
       #
       def callable_rpc_method(method_name)
-        lambda { run_filters(method_name) }
+        -> { run_filters(method_name) }
       end
 
       # Response object for this rpc cycle. Not assignable.
       #
       def response
-        @_response ||= response_type.new
+        @response ||= response_type.new
       end
 
       # Convenience method to get back to class method.
@@ -147,10 +147,10 @@ module Protobuf
         self.class.rpcs
       end
 
-    private
+      private
 
       def request_type
-        @_request_type ||= env.request_type
+        @request_type ||= env.request_type
       end
 
       # Sugar to make an rpc method feel like a controller method.
@@ -158,19 +158,19 @@ module Protobuf
       # object returned by the response reader.
       #
       def respond_with(candidate)
-        @_response = candidate
+        @response = candidate
       end
       alias_method :return_from_whence_you_came, :respond_with
 
       def response_type
-        @_response_type ||= env.response_type
+        @response_type ||= env.response_type
       end
 
       # Automatically fail a service method.
       #
       def rpc_failed(message)
         message = message.message if message.respond_to?(:message)
-        raise RpcFailed.new(message)
+        fail RpcFailed, message
       end
     end
 

data/lib/protobuf/rpc/service_directory.rb

@@ -17,7 +17,7 @@ module Protobuf
       DEFAULT_PORT = 53000
       DEFAULT_TIMEOUT = 1
 
-      class Listing < Delegator
+      class Listing < SimpleDelegator
         attr_reader :expires_at
 
         def initialize(server)
@@ -45,13 +45,9 @@ module Protobuf
         end
 
         def update(server)
-          @server = server
+          __setobj__(server)
           @expires_at = Time.now.to_i + ttl
         end
-
-        def __getobj__
-          @server
-        end
       end
 
       # Class Methods
@@ -70,11 +66,11 @@ module Protobuf
 
       def self.start
         yield(self) if block_given?
-        self.instance.start
+        instance.start
       end
 
       def self.stop
-        self.instance.stop
+        instance.stop
       end
 
       #
@@ -117,7 +113,7 @@ module Protobuf
         unless running?
           init_socket
           logger.info { sign_message("listening to udp://#{self.class.address}:#{self.class.port}") }
-          @thread = Thread.new { self.send(:run) }
+          @thread = Thread.new { send(:run) }
         end
 
         self
@@ -200,11 +196,11 @@ module Protobuf
       end
 
       def remove_listing(uuid)
-        listing = @listings_by_uuid[uuid] or return
+        listing = @listings_by_uuid[uuid] || return
 
         logger.debug { sign_message("Removing listing: #{listing.inspect}") }
 
-        @listings_by_service.each do |service, listings|
+        @listings_by_service.each_value do |listings|
           listings.delete(listing)
         end
 

data/lib/protobuf/rpc/service_dispatcher.rb

@@ -7,7 +7,7 @@ module Protobuf
 
       attr_reader :env
 
-      def initialize(app)
+      def initialize(_app)
         # End of the line...
       end
 
@@ -22,12 +22,12 @@ module Protobuf
         @rpc_service ||= env.rpc_service.new(env)
       end
 
-    private
+      private
 
       # Call the given service method.
       def dispatch_rpc_request
         unless rpc_service.respond_to?(method_name)
-          raise MethodNotFound.new("#{service_name}##{method_name} is not a publicly defined method.")
+          fail MethodNotFound, "#{service_name}##{method_name} is not a publicly defined method."
         end
 
         rpc_service.callable_rpc_method(method_name).call

data/lib/protobuf/rpc/service_filters.rb

@@ -24,7 +24,7 @@ module Protobuf
         # whose values are Sets.
         #
         def filters
-          @filters ||= Hash.new { |h,k| h[k] = [] }
+          @filters ||= Hash.new { |h, k| h[k] = [] }
         end
 
         # Filters hash keyed based on filter type (e.g. :before, :after, :around),
@@ -37,7 +37,7 @@ module Protobuf
         def rescue_from(*ex_klasses, &block)
           options = ex_klasses.last.is_a?(Hash) ? ex_klasses.pop : {}
           callable = options.delete(:with) { block }
-          raise ArgumentError, 'Option :with missing from rescue_from options' if callable.nil?
+          fail ArgumentError, 'Option :with missing from rescue_from options' if callable.nil?
           ex_klasses.each { |ex_klass| rescue_filters[ex_klass] = callable }
         end
 
@@ -45,12 +45,12 @@ module Protobuf
 
         def define_filter(type, filter, options = {})
           return if filter_defined?(type, filter)
-          filters[type] << options.merge({ :callable => filter })
+          filters[type] << options.merge(:callable => filter)
           remember_filter(type, filter)
         end
 
         def defined_filters
-          @defined_filters ||= Hash.new { |h,k| h[k] = Set.new }
+          @defined_filters ||= Hash.new { |h, k| h[k] = Set.new }
         end
 
         # Check to see if the filter has been defined.
@@ -66,8 +66,8 @@ module Protobuf
         end
 
         # Takes a list of actually (or potentially) callable objects.
-        # TODO add support for if/unless
-        # TODO add support for only/except sub-filters
+        # TODO: add support for if/unless
+        # TODO: add support for only/except sub-filters
         #
         def set_filters(type, *args)
           options = args.last.is_a?(Hash) ? args.pop : {}
@@ -94,7 +94,7 @@ module Protobuf
         # if the filter should not be invoked, true if invocation should occur.
         #
         def invoke_filter?(rpc_method, filter)
-          return invoke_via_only?(rpc_method, filter) \
+          invoke_via_only?(rpc_method, filter) \
             && invoke_via_except?(rpc_method, filter) \
             && invoke_via_if?(rpc_method, filter) \
             && invoke_via_unless?(rpc_method, filter)
@@ -108,8 +108,8 @@ module Protobuf
         # Value should be a symbol/string or an array of symbols/strings.
         #
         def invoke_via_except?(rpc_method, filter)
-          except = [ filter.fetch(:except) { [] } ].flatten
-          return except.empty? || ! except.include?(rpc_method)
+          except = [filter.fetch(:except) { [] }].flatten
+          except.empty? || !except.include?(rpc_method)
         end
 
         # Invoke the given :if callable (if any) and return its return value.
@@ -119,8 +119,8 @@ module Protobuf
         # Value can either be a symbol/string indicating an instance method to call
         # or an object that responds to `call`.
         #
-        def invoke_via_if?(rpc_method, filter)
-          if_check = filter.fetch(:if) { lambda { |service| return true } }
+        def invoke_via_if?(_rpc_method, filter)
+          if_check = filter.fetch(:if) { ->(_service) { return true } }
           do_invoke = case
                       when if_check.nil? then
                         true
@@ -128,7 +128,7 @@ module Protobuf
                         call_or_send(if_check)
                       end
 
-          return do_invoke
+          do_invoke
         end
 
         # If the target rpc endpoint method is listed in the :only option,
@@ -138,8 +138,8 @@ module Protobuf
         # Value should be a symbol/string or an array of symbols/strings.
         #
         def invoke_via_only?(rpc_method, filter)
-          only = [ filter.fetch(:only) { [] } ].flatten
-          return only.empty? || only.include?(rpc_method)
+          only = [filter.fetch(:only) { [] }].flatten
+          only.empty? || only.include?(rpc_method)
         end
 
         # Invoke the given :unless callable (if any) and return the opposite
@@ -149,8 +149,8 @@ module Protobuf
         # Value can either be a symbol/string indicating an instance method to call
         # or an object that responds to `call`.
         #
-        def invoke_via_unless?(rpc_method, filter)
-          unless_check = filter.fetch(:unless) { lambda { |service| return false } }
+        def invoke_via_unless?(_rpc_method, filter)
+          unless_check = filter.fetch(:unless) { ->(_service) { return false } }
           skip_invoke = case
                         when unless_check.nil? then
                           false
@@ -158,7 +158,7 @@ module Protobuf
                           call_or_send(unless_check)
                         end
 
-          return ! skip_invoke
+          !skip_invoke
         end
 
         def rescue_filters
@@ -176,7 +176,7 @@ module Protobuf
             end
           end
 
-          return true
+          true
         end
 
         # Reverse build a chain of around filters. To implement an around chain,
@@ -209,17 +209,16 @@ module Protobuf
         #   end
         #
         def run_around_filters(rpc_method)
-          final = lambda { __send__(rpc_method) }
-          filters[:around].reverse.inject(final) { |previous, filter|
+          final = -> { __send__(rpc_method) }
+          filters[:around].reverse.reduce(final) do |previous, filter|
             if invoke_filter?(rpc_method, filter)
-              lambda { call_or_send(filter[:callable], &previous) }
+              -> { call_or_send(filter[:callable], &previous) }
             else
               previous
             end
-          }.call
+          end.call
         end
 
-
         # Entry method to call each filter type in the appropriate order. This should
         # be used instead of the other run methods directly.
         #
@@ -240,10 +239,10 @@ module Protobuf
             begin
               yield
             rescue *rescue_filters.keys => ex
-              callable = rescue_filters.fetch(ex.class) {
-                mapped_klass = rescue_filters.keys.detect { |child_klass| ex.class < child_klass }
+              callable = rescue_filters.fetch(ex.class) do
+                mapped_klass = rescue_filters.keys.find { |child_klass| ex.class < child_klass }
                 rescue_filters[mapped_klass]
-              }
+              end
 
               call_or_send(callable, ex)
             end
@@ -260,10 +259,10 @@ module Protobuf
                          when respond_to?(callable, true) then
                            __send__(callable, *args, &block)
                          else
-                           raise "Object #{callable} is not callable"
+                           fail "Object #{callable} is not callable"
                          end
 
-          return return_value
+          return_value
         end
 
       end