protobuffy 3.6.0 → 4.0.0

data/lib/protobuf/rpc/service_directory.rb

@@ -9,15 +9,23 @@ require 'protobuf/rpc/dynamic_discovery.pb'
 
 module Protobuf
   module Rpc
+    def self.service_directory
+      @service_directory ||= ::Protobuf::Rpc::ServiceDirectory.instance
+    end
+
+    def self.service_directory=(directory)
+      @service_directory = directory
+    end
+
     class ServiceDirectory
       include ::Singleton
-      include ::Protobuf::Logger::LogMethods
+      include ::Protobuf::Logging
 
-      DEFAULT_ADDRESS = "0.0.0.0"
+      DEFAULT_ADDRESS = '0.0.0.0'.freeze
       DEFAULT_PORT = 53000
       DEFAULT_TIMEOUT = 1
 
-      class Listing < Delegator
+      class Listing < SimpleDelegator
         attr_reader :expires_at
 
         def initialize(server)
@@ -45,13 +53,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 +74,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
 
       #
@@ -86,6 +90,7 @@ module Protobuf
 
       def all_listings_for(service)
         if running? && @listings_by_service.key?(service.to_s)
+          start_listener_thread if listener_dead?
           @listings_by_service[service.to_s].entries.shuffle
         else
           []
@@ -93,15 +98,19 @@ module Protobuf
       end
 
       def each_listing(&block)
+        start_listener_thread if listener_dead?
         @listings_by_uuid.each_value(&block)
       end
 
       def lookup(service)
-        if running?
-          if @listings_by_service.key?(service.to_s)
-            @listings_by_service[service.to_s].entries.sample
-          end
-        end
+        return unless running?
+        start_listener_thread if listener_dead?
+        return unless @listings_by_service.key?(service.to_s)
+        @listings_by_service[service.to_s].entries.sample
+      end
+
+      def listener_dead?
+        @thread.nil? || !@thread.alive?
       end
 
       def restart
@@ -110,22 +119,29 @@ module Protobuf
       end
 
       def running?
-        !!@thread.try(:alive?)
+        !!@running
       end
 
       def start
         unless running?
           init_socket
-          log_info { sign_message("listening to udp://#{self.class.address}:#{self.class.port}") }
-          @thread = Thread.new { self.send(:run) }
+          logger.info { sign_message("listening to udp://#{self.class.address}:#{self.class.port}") }
+          @running = true
         end
 
+        start_listener_thread if listener_dead?
         self
       end
 
+      def start_listener_thread
+        return if @thread.try(:alive?)
+        @thread = Thread.new { send(:run) }
+      end
+
       def stop
-        log_info { sign_message("Stopping directory") }
+        logger.info { sign_message("Stopping directory") }
 
+        @running = false
         @thread.try(:kill).try(:join)
         @socket.try(:close)
 
@@ -151,7 +167,7 @@ module Protobuf
         end
 
         trigger(action, listing)
-        log_debug { sign_message("#{action} server: #{server.inspect}") }
+        logger.debug { sign_message("#{action} server: #{server.inspect}") }
       end
 
       def init_socket
@@ -177,7 +193,7 @@ module Protobuf
             remove_listing(uuid)
           end
         else
-          log_info { sign_message("Ignoring incomplete beacon: #{beacon.inspect}") }
+          logger.info { sign_message("Ignoring incomplete beacon: #{beacon.inspect}") }
         end
       end
 
@@ -193,18 +209,18 @@ module Protobuf
       end
 
       def remove_expired_listings
-        log_debug { sign_message("Removing expired listings") }
+        logger.debug { sign_message("Removing expired listings") }
         @listings_by_uuid.each do |uuid, listing|
           remove_listing(uuid) if listing.expired?
         end
       end
 
       def remove_listing(uuid)
-        listing = @listings_by_uuid[uuid] or return
+        listing = @listings_by_uuid[uuid] || return
 
-        log_debug { sign_message("Removing listing: #{listing.inspect}") }
+        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
 
@@ -219,7 +235,7 @@ module Protobuf
       end
 
       def run
-        sweep_interval = 1 # sweep expired listings every 1 second
+        sweep_interval = 5 # sweep expired listings every 5 seconds
         next_sweep = Time.now.to_i + sweep_interval
 
         loop do
@@ -233,7 +249,7 @@ module Protobuf
           end
         end
       rescue => e
-        log_debug { sign_message("ERROR: (#{e.class}) #{e.message}\n#{e.backtrace.join("\n")}") }
+        logger.debug { sign_message("ERROR: (#{e.class}) #{e.message}\n#{e.backtrace.join("\n")}") }
         retry
       end
 

data/lib/protobuf/rpc/service_dispatcher.rb

@@ -1,17 +1,21 @@
-require 'protobuf/logger'
+require 'protobuf/logging'
 
 module Protobuf
   module Rpc
     class ServiceDispatcher
-      include ::Protobuf::Logger::LogMethods
+      include ::Protobuf::Logging
 
       attr_reader :env
 
-      def initialize(app)
+      def initialize(_app)
         # End of the line...
       end
 
       def call(env)
+        dup._call(env)
+      end
+
+      def _call(env)
         @env = env
 
         env.response = dispatch_rpc_request
@@ -22,15 +26,10 @@ 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.")
-        end
-
-        rpc_service.callable_rpc_method(method_name).call
+        rpc_service.call(method_name)
         rpc_service.response
       end
 

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,10 +94,10 @@ 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_except?(rpc_method, filter) \
-            && invoke_via_if?(rpc_method, filter) \
-            && invoke_via_unless?(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)
         end
 
         # If the target rpc endpoint method is listed under an :except option,
@@ -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,16 +119,10 @@ 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 } }
-          do_invoke = case
-                      when if_check.nil? then
-                        true
-                      else
-                        call_or_send(if_check)
-                      end
-
-          return do_invoke
+        def invoke_via_if?(_rpc_method, filter)
+          if_check = filter.fetch(:if, nil)
+          return true if if_check.nil?
+          call_or_send(if_check)
         end
 
         # If the target rpc endpoint method is listed in the :only option,
@@ -138,8 +132,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,16 +143,10 @@ 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 } }
-          skip_invoke = case
-                        when unless_check.nil? then
-                          false
-                        else
-                          call_or_send(unless_check)
-                        end
-
-          return ! skip_invoke
+        def invoke_via_unless?(_rpc_method, filter)
+          unless_check = filter.fetch(:unless, nil)
+          return true if unless_check.nil?
+          !call_or_send(unless_check)
         end
 
         def rescue_filters
@@ -176,7 +164,7 @@ module Protobuf
             end
           end
 
-          return true
+          true
         end
 
         # Reverse build a chain of around filters. To implement an around chain,
@@ -209,17 +197,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 +227,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
@@ -254,20 +241,10 @@ module Protobuf
         # __send__ assuming that we respond_to it. Return the call's return value.
         #
         def call_or_send(callable, *args, &block)
-          return_value = case
-                         when callable.respond_to?(:call) then
-                           callable.call(self, *args, &block)
-                         when respond_to?(callable, true) then
-                           __send__(callable, *args, &block)
-                         else
-                           raise "Object #{callable} is not callable"
-                         end
-
-          return return_value
+          return callable.call(self, *args, &block) if callable.respond_to?(:call)
+          __send__(callable, *args, &block)
         end
-
       end
-
     end
   end
 end

data/lib/protobuf/rpc/stat.rb

@@ -1,6 +1,5 @@
 require 'date'
 require 'time'
-require 'protobuf/logger'
 require 'protobuf/statsd'
 
 module Protobuf
@@ -20,9 +19,7 @@ module Protobuf
         start
       end
 
-      def client=(client_host)
-        @client = client_host
-      end
+      attr_writer :client
 
       def client
         @client || nil
@@ -37,7 +34,7 @@ module Protobuf
       end
 
       def server=(peer)
-        @server = {:port => peer[0], :ip => peer[1]}
+        @server = { :port => peer[0], :ip => peer[1] }
       end
 
       def server
@@ -75,7 +72,7 @@ module Protobuf
       end
 
       def stopped?
-        ! end_time.nil?
+        !end_time.nil?
       end
 
       def rpc
@@ -98,7 +95,7 @@ module Protobuf
           rpc,
           sizes,
           elapsed_time,
-          @end_time.try(:iso8601)
+          @end_time.try(:iso8601),
         ].compact.join(' - ')
       end
 
@@ -134,4 +131,3 @@ module Protobuf
     end
   end
 end
-