queue-bus 0.6.0 → 0.9.1

data/lib/queue_bus/dispatch.rb

@@ -1,23 +1,25 @@
+# frozen_string_literal: true
+
 # Creates a DSL for apps to define their blocks to run for event_types
 
 module QueueBus
+  # A Dispatch object can be used to declare an application along with it's various subscriptions.
   class Dispatch
-
     attr_reader :app_key, :subscriptions
-    
+
     def initialize(app_key)
       @app_key = Application.normalize(app_key)
       @subscriptions = SubscriptionList.new
     end
-    
+
     def size
       @subscriptions.size
     end
-    
+
     def subscribe(key, matcher_hash = nil, &block)
-      dispatch_event("default", key, matcher_hash, block)
+      dispatch_event('default', key, matcher_hash, block)
     end
-    
+
     # allows definitions of other queues
     def method_missing(method_name, *args, &block)
       if args.size == 1 && block
@@ -28,7 +30,7 @@ module QueueBus
         super
       end
     end
-    
+
     def execute(key, attributes)
       sub = subscriptions.key(key)
       if sub
@@ -41,17 +43,17 @@ module QueueBus
     def subscription_matches(attributes)
       out = subscriptions.matches(attributes)
       out.each do |sub|
-        sub.app_key = self.app_key
+        sub.app_key = app_key
       end
       out
     end
-    
+
     def dispatch_event(queue, key, matcher_hash, block)
       # if not matcher_hash, assume key is a event_type regex
-      matcher_hash ||= { "bus_event_type" => key }
-      add_subscription("#{app_key}_#{queue}", key, "::QueueBus::Rider", matcher_hash, block)
+      matcher_hash ||= { 'bus_event_type' => key }
+      add_subscription("#{app_key}_#{queue}", key, '::QueueBus::Rider', matcher_hash, block)
     end
-    
+
     def add_subscription(queue_name, key, class_name, matcher_hash = nil, block)
       sub = Subscription.register(queue_name, key, class_name, matcher_hash, block)
       subscriptions.add(sub)

data/lib/queue_bus/dispatchers.rb

@@ -1,26 +1,33 @@
+# frozen_string_literal: true
+
 module QueueBus
+  # A collection of Dispatches
+  #
+  # Each Dispatch is an application with it's own set of subscriptions. This is a master object
+  # that provides some basic controls over the set of applications.
   class Dispatchers
-    def dispatch(app_key=nil, &block)
+    # Fetches a dispatch for the application key and binds the provided block to it.
+    def dispatch(app_key = nil, &block)
       dispatcher = dispatcher_by_key(app_key)
       dispatcher.instance_eval(&block)
       dispatcher
     end
-    
+
     def dispatchers
       @dispatchers ||= {}
       @dispatchers.values
     end
-    
+
     def dispatcher_by_key(app_key)
       app_key = Application.normalize(app_key || ::QueueBus.default_app_key)
       @dispatchers ||= {}
       @dispatchers[app_key] ||= Dispatch.new(app_key)
     end
-    
+
     def dispatcher_execute(app_key, key, attributes)
       @dispatchers ||= {}
       dispatcher = @dispatchers[app_key]
-      dispatcher.execute(key, attributes) if dispatcher
+      dispatcher&.execute(key, attributes)
     end
   end
 end

data/lib/queue_bus/driver.rb

@@ -1,7 +1,13 @@
+# frozen_string_literal: true
+
 module QueueBus
-  # fans out an event to multiple queues
+  # Fans out an event to multiple queues
+  #
+  # When a single event is broadcast, it may have zero to many subscriptions attached to it.
+  # The Driver is what is run in order to look up the subscription matches and enqueue each
+  # of the jobs. It uses the class_name supplied by the subscription to know which class will
+  # be performed.
   class Driver
-
     class << self
       def subscription_matches(attributes)
         out = []
@@ -12,24 +18,23 @@ module QueueBus
         out
       end
 
-      def perform(attributes={})
-        raise "No attributes passed" if attributes.empty?
+      def perform(attributes = {})
+        raise 'No attributes passed' if attributes.empty?
 
         ::QueueBus.log_worker("Driver running: #{attributes.inspect}")
 
         subscription_matches(attributes).each do |sub|
           ::QueueBus.log_worker("  ...sending to #{sub.queue_name} queue with class #{sub.class_name} for app #{sub.app_key} because of subscription: #{sub.key}")
 
-          bus_attr = {  "bus_driven_at" => Time.now.to_i,
-                        "bus_rider_queue" => sub.queue_name,
-                        "bus_rider_app_key" => sub.app_key,
-                        "bus_rider_sub_key" => sub.key,
-                        "bus_rider_class_name" => sub.class_name}
+          bus_attr = {  'bus_driven_at' => Time.now.to_i,
+                        'bus_rider_queue' => sub.queue_name,
+                        'bus_rider_app_key' => sub.app_key,
+                        'bus_rider_sub_key' => sub.key,
+                        'bus_rider_class_name' => sub.class_name }
           bus_attr = bus_attr.merge(attributes || {})
           ::QueueBus.enqueue_to(sub.queue_name, sub.class_name, bus_attr)
         end
       end
     end
-
   end
 end

data/lib/queue_bus/heartbeat.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module QueueBus
-  # publishes event about the current time
+  # When run, will calculate all of the heartbeats that need to be sent and then broadcasts
+  # those events out for execution. By always backfilling it ensures that no heartbeat is
+  # ever missed.
   class Heartbeat
-
     class << self
-
       def lock_key
-        "bus:heartbeat:lock"
+        'bus:heartbeat:lock'
       end
 
       def lock_seconds
@@ -38,71 +40,71 @@ module QueueBus
         ::QueueBus.redis { |redis| redis.del(lock_key) }
       end
 
-
       def redis_key
-        "bus:heartbeat:timestamp"
+        'bus:heartbeat:timestamp'
       end
 
       def environment_name
-        ENV["RAILS_ENV"] || ENV["RACK_ENV"] || ENV["BUS_ENV"]
+        ENV['RAILS_ENV'] || ENV['RACK_ENV'] || ENV['BUS_ENV']
       end
 
       def get_saved_minute!
         key = ::QueueBus.redis { |redis| redis.get(redis_key) }
         return nil if key.nil?
+
         case environment_name
         when 'development', 'test'
           # only 3 minutes in development; otherwise, TONS of events if not run in a while
-          three_ago = Time.now.to_i - 3*60*60
+          three_ago = Time.now.to_i / 60 - 3
           key = three_ago if key.to_i < three_ago
         end
-        return key.to_i
+        key.to_i
       end
 
       def set_saved_minute!(epoch_minute)
         ::QueueBus.redis { |redis| redis.set(redis_key, epoch_minute) }
       end
 
-      def perform(*args)
+      def perform(*_args)
         real_now = Time.now.to_i
         run_until = lock! - 2
         return if run_until < real_now
 
-        while((real_now = Time.now.to_i) < run_until)
+        while (real_now = Time.now.to_i) < run_until
           minutes = real_now.to_i / 60
           last = get_saved_minute!
           if last
             break if minutes <= last
+
             minutes = last + 1
           end
 
-          seconds = minutes * (60)
-          hours   = minutes / (60)
-          days    = minutes / (60*24)
+          seconds = minutes * 60
+          hours   = minutes / 60
+          days    = minutes / (60 * 24)
 
-          now     = Time.at(seconds)
+          now = Time.at(seconds)
 
           attributes = {}
-          attributes["epoch_seconds"] = seconds
-          attributes["epoch_minutes"] = minutes
-          attributes["epoch_hours"]   = hours
-          attributes["epoch_days"]    = days
-
-          attributes["minute"] = now.min
-          attributes["hour"]   = now.hour
-          attributes["day"]    = now.day
-          attributes["month"]  = now.month
-          attributes["year"]   = now.year
-          attributes["yday"]   = now.yday
-          attributes["wday"]   = now.wday
-
-          ::QueueBus.publish("heartbeat_minutes", attributes)
+          attributes['epoch_seconds'] = seconds
+          attributes['epoch_minutes'] = minutes
+          attributes['epoch_hours']   = hours
+          attributes['epoch_days']    = days
+
+          attributes['minute'] = now.min
+          attributes['hour']   = now.hour
+          attributes['day']    = now.day
+          attributes['month']  = now.month
+          attributes['year']   = now.year
+          attributes['yday']   = now.yday
+          attributes['wday']   = now.wday
+
+          ::QueueBus.publish('heartbeat_minutes', attributes)
           set_saved_minute!(minutes)
         end
 
         unlock!
       end
     end
-
   end
 end

data/lib/queue_bus/local.rb

@@ -1,12 +1,13 @@
+# frozen_string_literal: true
+
 module QueueBus
   # only process local queues
   class Local
-
     class << self
       def publish(attributes = {})
         if ::QueueBus.local_mode == :suppress
           ::QueueBus.log_worker("Suppressed: #{attributes.inspect}")
-          return  # not doing anything
+          return # not doing anything
         end
 
         # To json and back to simlulate enqueueing
@@ -17,15 +18,15 @@ module QueueBus
 
         # looking for subscriptions, not queues
         subscription_matches(attributes).each do |sub|
-          bus_attr = {  "bus_driven_at" => Time.now.to_i,
-                        "bus_rider_queue" => sub.queue_name,
-                        "bus_rider_app_key" => sub.app_key,
-                        "bus_rider_sub_key" => sub.key,
-                        "bus_rider_class_name" => sub.class_name}
+          bus_attr = {  'bus_driven_at' => Time.now.to_i,
+                        'bus_rider_queue' => sub.queue_name,
+                        'bus_rider_app_key' => sub.app_key,
+                        'bus_rider_sub_key' => sub.key,
+                        'bus_rider_class_name' => sub.class_name }
           to_publish = bus_attr.merge(attributes || {})
           if ::QueueBus.local_mode == :standalone
             ::QueueBus.enqueue_to(sub.queue_name, sub.class_name, bus_attr.merge(attributes || {}))
-          else  # defaults to inline mode
+          else # defaults to inline mode
             sub.execute!(to_publish)
           end
         end
@@ -41,6 +42,5 @@ module QueueBus
         out
       end
     end
-
   end
 end

data/lib/queue_bus/matcher.rb

@@ -1,70 +1,80 @@
+# frozen_string_literal: true
+
 module QueueBus
+  # Tests whether a field on a bus event matches a filter.
   class Matcher
-    SPECIAL_PREPEND = "bus_special_value_"
+    SPECIAL_PREPEND = 'bus_special_value_'
     attr_reader :filters
     def initialize(hash)
       @filters = encode(hash)
     end
-    
+
     def to_redis
       @filters
     end
-    
+
     def match?(attribute_name, attributes)
       mine = filters[attribute_name].to_s
-      return false if mine.size == 0
-      
+      return false if mine.empty?
+
       given = attributes[attribute_name]
       case mine
       when "#{SPECIAL_PREPEND}key"
-        return true if attributes.has_key?(attribute_name)
+        return true if attributes.key?(attribute_name)
+
         return false
       when "#{SPECIAL_PREPEND}blank"
-        return true if given.to_s.strip.size == 0
+        return true if given.to_s.strip.empty?
+
         return false
       when "#{SPECIAL_PREPEND}empty"
-        return false if given == nil
-        return true if given.to_s.size == 0
+        return false if given.nil?
+        return true if given.to_s.empty?
+
         return false
       when "#{SPECIAL_PREPEND}nil"
-        return true if given == nil
+        return true if given.nil?
+
         return false
       when "#{SPECIAL_PREPEND}value"
-        return false if given == nil
+        return false if given.nil?
+
         return true
       when "#{SPECIAL_PREPEND}present"
-        return true if given.to_s.strip.size > 0
+        return true unless given.to_s.strip.empty?
+
         return false
       end
-      
+
       given = given.to_s
-      
+
       return true if mine == given
+
       begin
         # if it's already a regex, don't mess with it
         # otherwise, it should have start and end line situation
-        if mine[0..6] == "(?-mix:"
-          regex = Regexp.new(mine)
-        else
-          regex = Regexp.new("^#{mine}$")
-        end
+        regex = if mine[0..6] == '(?-mix:'
+                  Regexp.new(mine)
+                else
+                  Regexp.new("^#{mine}$")
+                end
         return !!regex.match(given)
-      rescue
+      rescue StandardError
         return false
       end
     end
-    
+
     def matches?(attributes)
       return false if filters.empty?
-      return false if attributes == nil
-      
+      return false if attributes.nil?
+
       filters.keys.each do |key|
         return false unless match?(key, attributes)
       end
-      
+
       true
     end
-    
+
     def encode(hash)
       out = {}
       hash.each do |key, value|
@@ -73,9 +83,8 @@ module QueueBus
           value = "#{SPECIAL_PREPEND}#{value}"
         end
         out[key.to_s] = value.to_s
-      end      
+      end
       out
     end
   end
 end
-

data/lib/queue_bus/publisher.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 module QueueBus
-  # publishes on a delay
+  # A simple publishing worker for QueueBus. Makes publishing asynchronously possible since
+  # it may be enqueued to the background worker with a delay. This will allow the event to
+  # be published at a later time.
   class Publisher
-
     class << self
       def perform(attributes)
-        event_type = attributes["bus_event_type"]
+        event_type = attributes['bus_event_type']
         ::QueueBus.log_worker("Publisher running: #{event_type} - #{attributes.inspect}")
         ::QueueBus.publish(event_type, attributes)
       end
     end
-
   end
-end
+end