queue-bus 0.6.0 → 0.9.1

data/lib/queue_bus/publishing.rb

@@ -1,18 +1,22 @@
+# frozen_string_literal: true
+
 module QueueBus
+  # The publishing mixin provides the main interactions that users will use
+  # to interact with the queue bus. This module is not interacted with directly and instead
+  # is included inte the `QueueBus` module.
   module Publishing
-
     def with_global_attributes(attributes)
       original_timezone = false
       original_locale   = false
 
-      if attributes["bus_locale"] && defined?(I18n) && I18n.respond_to?(:locale=)
+      if attributes['bus_locale'] && defined?(I18n) && I18n.respond_to?(:locale=)
         original_locale = I18n.locale if I18n.respond_to?(:locale)
-        I18n.locale = attributes["bus_locale"]
+        I18n.locale = attributes['bus_locale']
       end
 
-      if attributes["bus_timezone"] && defined?(Time) && Time.respond_to?(:zone=)
+      if attributes['bus_timezone'] && defined?(Time) && Time.respond_to?(:zone=)
         original_timezone = Time.zone if Time.respond_to?(:zone)
-        Time.zone = attributes["bus_timezone"]
+        Time.zone = attributes['bus_timezone']
       end
 
       yield
@@ -21,13 +25,17 @@ module QueueBus
       Time.zone   = original_timezone unless original_timezone == false
     end
 
-    def publish_metadata(event_type, attributes={})
+    def publish_metadata(event_type, attributes = {})
       # TODO: "bus_app_key" => application.app_key ?
-      bus_attr = {"bus_published_at" => Time.now.to_i, "bus_event_type" => event_type}
-      bus_attr["bus_id"]           = "#{Time.now.to_i}-#{generate_uuid}"
-      bus_attr["bus_app_hostname"] = ::QueueBus.hostname
-      bus_attr["bus_locale"]       = I18n.locale.to_s if defined?(I18n) && I18n.respond_to?(:locale) && I18n.locale
-      bus_attr["bus_timezone"]     = Time.zone.name   if defined?(Time) && Time.respond_to?(:zone)   && Time.zone
+      bus_attr = { 'bus_published_at' => Time.now.to_i, 'bus_event_type' => event_type }
+      bus_attr['bus_id']           = "#{Time.now.to_i}-#{generate_uuid}"
+      bus_attr['bus_app_hostname'] = ::QueueBus.hostname
+      if defined?(I18n) && I18n.respond_to?(:locale) && I18n.locale
+        bus_attr['bus_locale']       = I18n.locale.to_s
+      end
+      if defined?(Time) && Time.respond_to?(:zone) && Time.zone
+        bus_attr['bus_timezone']     = Time.zone.name
+      end
       out = bus_attr.merge(attributes || {})
       ::QueueBus.before_publish_callback(out)
       out
@@ -35,15 +43,14 @@ module QueueBus
 
     def generate_uuid
       require 'securerandom' unless defined?(SecureRandom)
-      return SecureRandom.uuid
-
-      rescue Exception => e
-        # secure random not there
-        # big random number a few times
-        n_bytes = [42].pack('i').size
-        n_bits = n_bytes * 8
-        max = 2 ** (n_bits - 2) - 1
-        return "#{rand(max)}-#{rand(max)}-#{rand(max)}"
+      SecureRandom.uuid
+    rescue Exception => e
+      # secure random not there
+      # big random number a few times
+      n_bytes = [42].pack('i').size
+      n_bits = n_bytes * 8
+      max = 2**(n_bits - 2) - 1
+      "#{rand(max)}-#{rand(max)}-#{rand(max)}"
     end
 
     def publish(event_type, attributes = {})
@@ -59,9 +66,9 @@ module QueueBus
 
     def publish_at(timestamp_or_epoch, event_type, attributes = {})
       to_publish = publish_metadata(event_type, attributes)
-      to_publish["bus_delayed_until"] ||= timestamp_or_epoch.to_i
-      to_publish.delete("bus_published_at") unless attributes["bus_published_at"] # will be put on when it actually does it
-      to_publish["bus_class_proxy"] = ::QueueBus::Publisher.name.to_s
+      to_publish['bus_delayed_until'] ||= timestamp_or_epoch.to_i
+      to_publish.delete('bus_published_at') unless attributes['bus_published_at'] # will be put on when it actually does it
+      to_publish['bus_class_proxy'] = ::QueueBus::Publisher.name.to_s
 
       ::QueueBus.log_application("Event published:#{event_type} #{to_publish.inspect} publish_at: #{timestamp_or_epoch.to_i}")
       delayed_enqueue_to(timestamp_or_epoch.to_i, incoming_queue, ::QueueBus::Worker, to_publish)
@@ -69,7 +76,7 @@ module QueueBus
 
     def enqueue_to(queue_name, class_name, hash)
       class_name = class_name.name if class_name.is_a?(Class)
-      hash = hash.merge("bus_class_proxy" => class_name.to_s)
+      hash = hash.merge('bus_class_proxy' => class_name.to_s)
       ::QueueBus.adapter.enqueue(queue_name, ::QueueBus::Worker, ::QueueBus::Util.encode(hash || {}))
     end
 

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,29 @@
+# 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!
       count = 0
       ::QueueBus.dispatchers.each do |dispatcher|
@@ -29,10 +31,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 +43,12 @@ module QueueBus
           queues << sub.queue_name
         end
       end
-      
+
       queues.uniq
     end
-    
+
     def log(message)
       puts(message) if logging
     end
   end
-end
+end