queue-bus 0.7.0 → 0.10.0

data/lib/queue_bus/rider.rb

@@ -1,27 +1,31 @@
+# frozen_string_literal: true
+
 module QueueBus
-  # queue'd in each
+  # The Rider is meant to execute subscriptions.
+  #
+  # When your application has subscriptions to an event we still need to enqueue some executor that
+  # will execute the block that was registered. The Rider will effectively ride the bus for your
+  # subscribed event. One Rider is launched for each subscription on an event.
   class Rider
+    def self.perform(attributes = {})
+      sub_key = attributes['bus_rider_sub_key']
+      app_key = attributes['bus_rider_app_key']
+      raise 'No application key passed' if app_key.to_s == ''
+      raise 'No subcription key passed' if sub_key.to_s == ''
+
+      attributes ||= {}
+
+      ::QueueBus.log_worker("Rider received: #{app_key} #{sub_key} #{attributes.inspect}")
+
+      # attributes that should be available
+      # attributes["bus_event_type"]
+      # attributes["bus_app_key"]
+      # attributes["bus_published_at"]
+      # attributes["bus_driven_at"]
 
-    class << self
-      def perform(attributes = {})
-        sub_key = attributes["bus_rider_sub_key"]
-        app_key = attributes["bus_rider_app_key"]
-        raise "No application key passed" if app_key.to_s == ""
-        raise "No subcription key passed" if sub_key.to_s == ""
-        
-        attributes ||= {}
-        
-        ::QueueBus.log_worker("Rider received: #{app_key} #{sub_key} #{attributes.inspect}")
-        
-        # attributes that should be available
-        # attributes["bus_event_type"]
-        # attributes["bus_app_key"]
-        # attributes["bus_published_at"]
-        # attributes["bus_driven_at"]
-        
-        # (now running with the real app that subscribed)
-        ::QueueBus.dispatcher_execute(app_key, sub_key, attributes.merge("bus_executed_at" => Time.now.to_i))
-      end
+      # (now running with the real app that subscribed)
+      ::QueueBus.dispatcher_execute(app_key, sub_key,
+                                    attributes.merge('bus_executed_at' => Time.now.to_i))
     end
   end
-end
+end

data/lib/queue_bus/subscriber.rb

@@ -1,28 +1,33 @@
+# frozen_string_literal: true
+
 module QueueBus
+  # A mixin to configure subscriptions on a particular class
   module Subscriber
-
     def self.included(base)
       base.extend ClassMethods
     end
 
+    # The class methods that will be added to the class it's included in. Use them to
+    # configure and subscribe.
     module ClassMethods
-
       def application(app_key)
         @app_key = ::QueueBus::Application.normalize(app_key)
       end
 
       def app_key
         return @app_key if @app_key
+
         @app_key = ::QueueBus.default_app_key
         return @app_key if @app_key
+
         # module or class_name
-        val = self.name.to_s.split("::").first
+        val = name.to_s.split('::').first
         @app_key = ::QueueBus::Util.underscore(val)
       end
 
       def subscribe(method_name, matcher_hash = nil)
         queue_name   = nil
-        queue_name ||= self.instance_variable_get(:@queue) || (self.respond_to?(:queue) && self.queue)
+        queue_name ||= instance_variable_get(:@queue) || (respond_to?(:queue) && queue)
         queue_name ||= ::QueueBus.default_queue
         queue_name ||= "#{app_key}_default"
         subscribe_queue(queue_name, method_name, matcher_hash)
@@ -30,10 +35,11 @@ module QueueBus
 
       def subscribe_queue(queue_name, method_name, matcher_hash = nil)
         klass = self
-        matcher_hash ||= {"bus_event_type" => method_name}
-        sub_key = "#{self.name}.#{method_name}"
+        matcher_hash ||= { 'bus_event_type' => method_name }
+        sub_key = "#{name}.#{method_name}"
         dispatcher = ::QueueBus.dispatcher_by_key(app_key)
-        dispatcher.add_subscription(queue_name, sub_key, klass.name.to_s, matcher_hash, lambda{ |att| klass.perform(att) })
+        dispatcher.add_subscription(queue_name, sub_key, klass.name.to_s, matcher_hash,
+                                    ->(att) { klass.perform(att) })
       end
 
       def transform(method_name)
@@ -42,8 +48,8 @@ module QueueBus
 
       def perform(attributes)
         ::QueueBus.with_global_attributes(attributes) do
-          sub_key = attributes["bus_rider_sub_key"]
-          meth_key = sub_key.split(".").last
+          sub_key = attributes['bus_rider_sub_key']
+          meth_key = sub_key.split('.').last
           queue_bus_execute(meth_key, attributes)
         end
       end
@@ -52,11 +58,11 @@ module QueueBus
         args = attributes
         args = send(@transform, attributes) if @transform
         args = [args] unless args.is_a?(Array)
-        if self.respond_to?(:subscriber_with_attributes)
-          me = self.subscriber_with_attributes(attributes)
-        else
-          me = self.new
-        end
+        me = if respond_to?(:subscriber_with_attributes)
+               subscriber_with_attributes(attributes)
+             else
+               new
+             end
         me.send(key, *args)
       end
     end

data/lib/queue_bus/subscription.rb

@@ -1,29 +1,36 @@
+# frozen_string_literal: true
+
 module QueueBus
+  # A Subscription is the destination of an event.
+  #
+  # The subscription can be stored in redis but should only be executed on ruby processes that
+  # have the application loaded. In general, this is controlled by having the background workers
+  # listen to specific (and discrete) queues.
   class Subscription
-
     class << self
       def register(queue, key, class_name, matcher, block)
         Subscription.new(queue, key, class_name, matcher, block)
       end
 
       def from_redis(hash)
-        queue_name = hash["queue_name"].to_s
-        key        = hash["key"].to_s
-        class_name = hash["class"].to_s
-        matcher    = hash["matcher"]
-        return nil if key.length == 0 || queue_name.length == 0
+        queue_name = hash['queue_name'].to_s
+        key        = hash['key'].to_s
+        class_name = hash['class'].to_s
+        matcher    = hash['matcher']
+        return nil if key.empty? || queue_name.empty?
+
         Subscription.new(queue_name, key, class_name, matcher, nil)
       end
 
       def normalize(val)
-        val.to_s.gsub(/\W/, "_").downcase
+        val.to_s.gsub(/\W/, '_').downcase
       end
     end
 
     attr_reader :matcher, :executor, :queue_name, :key, :class_name
-    attr_accessor :app_key  # dyanmically set on return from subscription_matches
+    attr_accessor :app_key # dyanmically set on return from subscription_matches
 
-    def initialize(queue_name, key, class_name, filters, executor=nil)
+    def initialize(queue_name, key, class_name, filters, executor = nil)
       @queue_name = self.class.normalize(queue_name)
       @key        = key.to_s
       @class_name = class_name.to_s
@@ -31,8 +38,12 @@ module QueueBus
       @executor   = executor
     end
 
+    # Executes the subscription. If this is run on a server/ruby process that did not subscribe
+    # it will error as there will not be a proc.
     def execute!(attributes)
-      attributes = attributes.with_indifferent_access if attributes.respond_to?(:with_indifferent_access)
+      if attributes.respond_to?(:with_indifferent_access)
+        attributes = attributes.with_indifferent_access
+      end
       ::QueueBus.with_global_attributes(attributes) do
         executor.call(attributes)
       end
@@ -44,12 +55,11 @@ module QueueBus
 
     def to_redis
       out = {}
-      out["queue_name"] = queue_name
-      out["key"]        = key
-      out["class"]      = class_name
-      out["matcher"]    = matcher.to_redis
+      out['queue_name'] = queue_name
+      out['key']        = key
+      out['class']      = class_name
+      out['matcher']    = matcher.to_redis
       out
     end
-
   end
 end

data/lib/queue_bus/subscription_list.rb

@@ -1,11 +1,23 @@
+# frozen_string_literal: true
+
 module QueueBus
+  # Manages a set of subscriptions.
+  #
+  # The subscriptions are stored in redis but not by this class. Instead this class uses two
+  # functions `to_redis` and `from_redis` to facilitate serialization without accessing redis
+  # directly.
+  #
+  # To create a new SubscriptionList, use the static function `from_redis` and pass
+  # it a hash that came from redis.
+  #
+  # To get a value fro redis, take your loaded SubscriptionList and call `to_redis` on it. The
+  # returned value can be used to store in redis.
   class SubscriptionList
-
     class << self
       def from_redis(redis_hash)
         out = SubscriptionList.new
-        
-        redis_hash.each do |key, value|
+
+        redis_hash.each do |_key, value|
           sub = Subscription.from_redis(value)
           out.add(sub) if sub
         end
@@ -21,29 +33,35 @@ module QueueBus
       end
       out
     end
-    
+
     def initialize
       @subscriptions = {}
     end
-    
+
     def add(sub)
-      raise "Duplicate key: #{sub.key} already exists " \
-            "in the #{sub.queue_name} queue!" if @subscriptions.key?(sub.key)
+      if @subscriptions.key?(sub.key)
+        raise "Duplicate key: #{sub.key} already exists " \
+              "in the #{sub.queue_name} queue!"
+      end
       @subscriptions[sub.key] = sub
     end
-    
+
     def size
       @subscriptions.size
     end
-    
+
+    def empty?
+      size.zero?
+    end
+
     def key(key)
       @subscriptions[key.to_s]
     end
-    
+
     def all
       @subscriptions.values
     end
-    
+
     def matches(attributes)
       out = []
       all.each do |sub|
@@ -52,4 +70,4 @@ module QueueBus
       out
     end
   end
-end
+end

data/lib/queue_bus/task_manager.rb

@@ -1,27 +1,36 @@
+# frozen_string_literal: true
+
 module QueueBus
+  # A helper class for executing Rake tasks.
   class TaskManager
-
     attr_reader :logging
-    
+
     def initialize(logging)
       @logging = logging
     end
-    
+
     def subscribe!
       count = 0
       ::QueueBus.dispatchers.each do |dispatcher|
         subscriptions = dispatcher.subscriptions
-        if subscriptions.size > 0
-          count += subscriptions.size
-          log "Subscribing #{dispatcher.app_key} to #{subscriptions.size} subscriptions"
-          app = ::QueueBus::Application.new(dispatcher.app_key)
-          app.subscribe(subscriptions, logging)
-          log "  ...done"
-        end
+        next if subscriptions.empty?
+
+        count += subscriptions.size
+        log "Subscribing #{dispatcher.app_key} to #{subscriptions.size} subscriptions"
+        app = ::QueueBus::Application.new(dispatcher.app_key)
+        app.subscribe(subscriptions, logging)
+        log '  ...done'
       end
       count
     end
-    
+
+    def unsubscribe_queue!(app_key, queue)
+      log "Unsubcribing #{queue} from #{app_key}"
+      app = ::QueueBus::Application.new(app_key)
+      app.unsubscribe_queue(queue)
+      log "  ...done"
+    end
+
     def unsubscribe!
       count = 0
       ::QueueBus.dispatchers.each do |dispatcher|
@@ -29,10 +38,10 @@ module QueueBus
         app = ::QueueBus::Application.new(dispatcher.app_key)
         app.unsubscribe
         count += 1
-        log "  ...done"
+        log '  ...done'
       end
     end
-    
+
     def queue_names
       # let's not talk to redis in here. Seems to screw things up
       queues = []
@@ -41,12 +50,12 @@ module QueueBus
           queues << sub.queue_name
         end
       end
-      
+
       queues.uniq
     end
-    
+
     def log(message)
       puts(message) if logging
     end
   end
-end
+end

data/lib/queue_bus/tasks.rb

@@ -1,27 +1,50 @@
+# frozen_string_literal: true
+
 # require 'queue_bus/tasks'
-# will give you these tasks
+# A useful set of rake tasks for managing your bus
 
+# rubocop:disable Metrics/BlockLength
 namespace :queuebus do
-
-  desc "Subscribes this application to QueueBus events"
-  task :subscribe => [ :preload ] do
+  desc 'Subscribes this application to QueueBus events'
+  task subscribe: [:preload] do
     manager = ::QueueBus::TaskManager.new(true)
     count = manager.subscribe!
-    raise "No subscriptions created" if count == 0
+    raise 'No subscriptions created' if count == 0
   end
 
   desc "Unsubscribes this application from QueueBus events"
-  task :unsubscribe => [ :preload ] do
+  task :unsubscribe, [:app_key, :queue] => [ :preload ] do |task, args|
+    app_key = args[:app_key]
+    queue = args[:queue]
     manager = ::QueueBus::TaskManager.new(true)
-    count = manager.unsubscribe!
-    puts "No subscriptions unsubscribed" if count == 0
+
+    if app_key && queue
+      manager.unsubscribe_queue!(app_key, queue)
+    else
+      manager = ::QueueBus::TaskManager.new(true)
+      count = manager.unsubscribe!
+      puts "No subscriptions unsubscribed" if count == 0
+    end
   end
 
-  desc "List QueueBus queues that need worked"
-  task :queues => [ :preload ] do
+  desc 'List QueueBus queues that need worked'
+  task queues: [:preload] do
     manager = ::QueueBus::TaskManager.new(false)
     queues = manager.queue_names + ['bus_incoming']
-    puts queues.join(", ")
+    puts queues.join(', ')
+  end
+
+  desc 'list time based subscriptions'
+  task list_scheduled: [:preload] do
+    scheduled_list = QueueBus::Application.all.flat_map do |app|
+      app.send(:subscriptions).all
+         .select { |s| s.matcher.filters['bus_event_type'] == 'heartbeat_minutes' }
+    end
+    scheduled_text_list = scheduled_list.collect do |e|
+      [e.key, e.matcher.filters['hour'] || '*', e.matcher.filters['minute'] || '*']
+    end
+    puts 'key, hour, minute'
+    puts scheduled_text_list.sort_by { |(_, hour, minute)| [hour.to_i, minute.to_i] }.map(&:to_csv)
   end
 
   # Preload app files if this is Rails
@@ -30,3 +53,4 @@ namespace :queuebus do
     require 'queue-bus'
   end
 end
+# rubocop:enable Metrics/BlockLength

data/lib/queue_bus/util.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'multi_json'
 
 module QueueBus
@@ -30,14 +32,14 @@ module QueueBus
         raise DecodeException, e.message, e.backtrace
       end
     end
-    
+
     def underscore(camel_cased_word)
       word = camel_cased_word.to_s.dup
       word.gsub!('::', '/')
       # word.gsub!(/(?:([A-Za-z\d])|^)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
-      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
-      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
-      word.tr!("-", "_")
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      word.tr!('-', '_')
       word.downcase!
       word
     end
@@ -53,11 +55,11 @@ module QueueBus
       # string = string.sub(/^[a-z\d]*/) { inflections.acronyms[$&] || $&.capitalize }
       string = string.sub(/^[a-z\d]*/) { $&.capitalize }
       # string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{inflections.acronyms[$2] || $2.capitalize}" }
-      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
-      string.gsub!(/\//, '::')
+      string.gsub!(%r{(?:_|(/))([a-z\d]*)}i) { "#{Regexp.last_match(1)}#{Regexp.last_match(2).capitalize}" }
+      string.gsub!(%r{/}, '::')
       string
     end
-    
+
     def constantize(camel_cased_word)
       names = camel_cased_word.split('::')
       names.shift if names.empty? || names.first.empty?
@@ -75,6 +77,7 @@ module QueueBus
           constant = constant.ancestors.inject do |const, ancestor|
             break const    if ancestor == Object
             break ancestor if ancestor.const_defined?(name, false)
+
             const
           end
 
@@ -84,4 +87,4 @@ module QueueBus
       end
     end
   end
-end
+end