resque-bus 0.2.4 → 0.2.5

data/lib/resque-bus.rb

@@ -1,250 +1,254 @@
+require "resque_bus/version"
+
 require 'redis/namespace'
 require 'resque'
 
-require "resque_bus/version"
-require 'resque_bus/util'
-require 'resque_bus/matcher'
-require 'resque_bus/subscription'
-require 'resque_bus/subscription_list'
-require 'resque_bus/subscriber'
-require 'resque_bus/application'
-require 'resque_bus/publisher'
-require 'resque_bus/driver'
-require 'resque_bus/local'
-require 'resque_bus/rider'
-require 'resque_bus/dispatch'
-require 'resque_bus/task_manager'
 
 module ResqueBus
-  extend self
-  
-  def default_app_key=val
-    @default_app_key = Application.normalize(val)
-  end
-  
-  def default_app_key
-    @default_app_key
-  end
   
-  def default_queue=val
-    @default_queue = val
-  end
-  
-  def default_queue
-    @default_queue
-  end
+  autoload :Application,      'resque_bus/application'
+  autoload :Dispatch,         'resque_bus/dispatch'
+  autoload :Driver,           'resque_bus/driver'
+  autoload :Local,            'resque_bus/local'
+  autoload :Matcher,          'resque_bus/matcher'
+  autoload :Publisher,        'resque_bus/publisher'
+  autoload :Rider,            'resque_bus/rider'
+  autoload :Subscriber,       'resque_bus/subscriber'
+  autoload :Subscription,     'resque_bus/subscription'
+  autoload :SubscriptionList, 'resque_bus/subscription_list'
+  autoload :TaskManager,      'resque_bus/task_manager'
+  autoload :Util,             'resque_bus/util'
 
-  def hostname
-    @hostname ||= `hostname 2>&1`.strip.sub(/.local/,'')
-  end
-  
-  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 || 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
-  end
+  class << self
+    
+    def default_app_key=val
+      @default_app_key = Application.normalize(val)
+    end
+    
+    def default_app_key
+      @default_app_key
+    end
+    
+    def default_queue=val
+      @default_queue = val
+    end
+    
+    def default_queue
+      @default_queue
+    end
 
-  def local_mode=value
-    @local_mode = value
-  end
+    def hostname
+      @hostname ||= `hostname 2>&1`.strip.sub(/.local/,'')
+    end
+    
+    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 || 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
+    end
 
-  def local_mode
-    @local_mode
-  end
+    def local_mode=value
+      @local_mode = value
+    end
+
+    def local_mode
+      @local_mode
+    end
+
+    # Accepts:
+    #   1. A 'hostname:port' String
+    #   2. A 'hostname:port:db' String (to select the Redis db)
+    #   3. A 'hostname:port/namespace' String (to set the Redis namespace)
+    #   4. A Redis URL String 'redis://host:port'
+    #   5. An instance of `Redis`, `Redis::Client`, `Redis::DistRedis`,
+    #      or `Redis::Namespace`.
+    def redis=(server)
+      case server
+      when String
+        if server =~ /redis\:\/\//
+          redis = Redis.connect(:url => server, :thread_safe => true)
+        else
+          server, namespace = server.split('/', 2)
+          host, port, db = server.split(':')
+          redis = Redis.new(:host => host, :port => port,
+            :thread_safe => true, :db => db)
+        end
+        namespace ||= default_namespace
 
-  # Accepts:
-  #   1. A 'hostname:port' String
-  #   2. A 'hostname:port:db' String (to select the Redis db)
-  #   3. A 'hostname:port/namespace' String (to set the Redis namespace)
-  #   4. A Redis URL String 'redis://host:port'
-  #   5. An instance of `Redis`, `Redis::Client`, `Redis::DistRedis`,
-  #      or `Redis::Namespace`.
-  def redis=(server)
-    case server
-    when String
-      if server =~ /redis\:\/\//
-        redis = Redis.connect(:url => server, :thread_safe => true)
+        @redis = Redis::Namespace.new(namespace, :redis => redis)
+      when Redis::Namespace
+        @redis = server
       else
-        server, namespace = server.split('/', 2)
-        host, port, db = server.split(':')
-        redis = Redis.new(:host => host, :port => port,
-          :thread_safe => true, :db => db)
+        @redis = Redis::Namespace.new(default_namespace, :redis => server)
       end
-      namespace ||= default_namespace
-
-      @redis = Redis::Namespace.new(namespace, :redis => redis)
-    when Redis::Namespace
-      @redis = server
-    else
-      @redis = Redis::Namespace.new(default_namespace, :redis => server)
     end
-  end
 
-  # Returns the current Redis connection. If none has been created, will
-  # create a new one from the Reqsue one (with a different namespace)
-  def redis
-    return @redis if @redis
-    copy = Resque.redis.clone
-    copy.namespace = default_namespace
-    self.redis = copy
-    self.redis
-  end
-  
-  def original_redis=(server)
-    @original_redis = server
-  end
-  def original_redis
-    @original_redis
-  end
-  
-  def publish_metadata(event_type, attributes={})
-    # TODO: "bus_app_key" => application.app_key ?
-    bus_attr = {"bus_published_at" => Time.now.to_i, "created_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"] = hostname
-    bus_attr.merge(attributes || {})
-  end
-  
-  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)}"
-  end
-  
-  def publish(event_type, attributes = {})
-    to_publish = publish_metadata(event_type, attributes)
-    ResqueBus.log_application("Event published: #{event_type} #{to_publish.inspect}")
-    if local_mode
-      ResqueBus::Local.perform(to_publish)
-    else
-      enqueue_to(incoming_queue, Driver, to_publish)
+    # Returns the current Redis connection. If none has been created, will
+    # create a new one from the Reqsue one (with a different namespace)
+    def redis
+      return @redis if @redis
+      copy = Resque.redis.clone
+      copy.namespace = default_namespace
+      self.redis = copy
+      self.redis
     end
-  end
-  
-  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
-    
-    ResqueBus.log_application("Event published:#{event_type} #{to_publish.inspect} publish_at: #{timestamp_or_epoch.to_i}")
-    item = delayed_job_to_hash_with_queue(incoming_queue, Publisher, [event_type, to_publish])
-    delayed_push(timestamp_or_epoch, item)
-  end
-  
-  def enqueue_to(queue, klass, *args)
-    push(queue, :class => klass.to_s, :args => args)
-  end
-  
-  def logger
-    @logger
-  end
-  
-  def logger=val
-    @logger = val
-  end
-  
-  def log_application(message)
-    if logger
-      time = Time.now.strftime('%H:%M:%S %Y-%m-%d')
-      logger.info("** [#{time}] #$$: ResqueBus #{message}")
+    
+    def original_redis=(server)
+      @original_redis = server
     end
-  end
-  
-  def log_worker(message)
-    if ENV['LOGGING'] || ENV['VERBOSE'] || ENV['VVERBOSE']
-      time = Time.now.strftime('%H:%M:%S %Y-%m-%d')
-      puts "** [#{time}] #$$: #{message}"
+    def original_redis
+      @original_redis
+    end
+    
+    def publish_metadata(event_type, attributes={})
+      # TODO: "bus_app_key" => application.app_key ?
+      bus_attr = {"bus_published_at" => Time.now.to_i, "created_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"] = hostname
+      bus_attr.merge(attributes || {})
+    end
+    
+    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)}"
+    end
+    
+    def publish(event_type, attributes = {})
+      to_publish = publish_metadata(event_type, attributes)
+      ResqueBus.log_application("Event published: #{event_type} #{to_publish.inspect}")
+      if local_mode
+        ResqueBus::Local.perform(to_publish)
+      else
+        enqueue_to(incoming_queue, Driver, to_publish)
+      end
+    end
+    
+    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
+      
+      ResqueBus.log_application("Event published:#{event_type} #{to_publish.inspect} publish_at: #{timestamp_or_epoch.to_i}")
+      item = delayed_job_to_hash_with_queue(incoming_queue, Publisher, [event_type, to_publish])
+      delayed_push(timestamp_or_epoch, item)
+    end
+    
+    def enqueue_to(queue, klass, *args)
+      push(queue, :class => klass.to_s, :args => args)
+    end
+    
+    def logger
+      @logger
+    end
+    
+    def logger=val
+      @logger = val
+    end
+    
+    def log_application(message)
+      if logger
+        time = Time.now.strftime('%H:%M:%S %Y-%m-%d')
+        logger.info("** [#{time}] #$$: ResqueBus #{message}")
+      end
+    end
+    
+    def log_worker(message)
+      if ENV['LOGGING'] || ENV['VERBOSE'] || ENV['VVERBOSE']
+        time = Time.now.strftime('%H:%M:%S %Y-%m-%d')
+        puts "** [#{time}] #$$: #{message}"
+      end
+    end
+    
+    protected
+    
+    def reset
+      # used by tests
+      @redis = nil # clear instance of redis
+      @dispatcher = nil
+      @default_app_key = nil
+      @default_queue = nil
+    end
+    
+    def incoming_queue
+      "resquebus_incoming"
     end
-  end
-  
-  protected
-  
-  def reset
-    # used by tests
-    @redis = nil # clear instance of redis
-    @dispatcher = nil
-    @default_app_key = nil
-    @default_queue = nil
-  end
-  
-  def incoming_queue
-    "resquebus_incoming"
-  end
 
-  def default_namespace
-    # It might play better on the same server, but overall life is more complicated
-    :resque
-  end
-  
-  ## From Resque, but using a (possibly) different instance of Redis
-  
-  # Pushes a job onto a queue. Queue name should be a string and the
-  # item should be any JSON-able Ruby object.
-  #
-  # Resque works generally expect the `item` to be a hash with the following
-  # keys:
-  #
-  #   class - The String name of the job to run.
-  #    args - An Array of arguments to pass the job. Usually passed
-  #           via `class.to_class.perform(*args)`.
-  #
-  # Example
-  #
-  #   Resque.push('archive', :class => 'Archive', :args => [ 35, 'tar' ])
-  #
-  # Returns nothing
-  def push(queue, item)
-    watch_queue(queue)
-    redis.rpush "queue:#{queue}", Resque.encode(item)
-  end
-  
-  # Used internally to keep track of which queues we've created.
-  # Don't call this directly.
-  def watch_queue(queue)
-    redis.sadd(:queues, queue.to_s)
-  end
-  
-  ### From Resque Scheduler
-  # Used internally to stuff the item into the schedule sorted list.
-  # +timestamp+ can be either in seconds or a datetime object
-  # Insertion if O(log(n)).
-  # Returns true if it's the first job to be scheduled at that time, else false
-  def delayed_push(timestamp, item)
-    # First add this item to the list for this timestamp
-    redis.rpush("delayed:#{timestamp.to_i}", Resque.encode(item))
+    def default_namespace
+      # It might play better on the same server, but overall life is more complicated
+      :resque
+    end
+    
+    ## From Resque, but using a (possibly) different instance of Redis
+    
+    # Pushes a job onto a queue. Queue name should be a string and the
+    # item should be any JSON-able Ruby object.
+    #
+    # Resque works generally expect the `item` to be a hash with the following
+    # keys:
+    #
+    #   class - The String name of the job to run.
+    #    args - An Array of arguments to pass the job. Usually passed
+    #           via `class.to_class.perform(*args)`.
+    #
+    # Example
+    #
+    #   Resque.push('archive', :class => 'Archive', :args => [ 35, 'tar' ])
+    #
+    # Returns nothing
+    def push(queue, item)
+      watch_queue(queue)
+      redis.rpush "queue:#{queue}", Resque.encode(item)
+    end
+    
+    # Used internally to keep track of which queues we've created.
+    # Don't call this directly.
+    def watch_queue(queue)
+      redis.sadd(:queues, queue.to_s)
+    end
+    
+    ### From Resque Scheduler
+    # Used internally to stuff the item into the schedule sorted list.
+    # +timestamp+ can be either in seconds or a datetime object
+    # Insertion if O(log(n)).
+    # Returns true if it's the first job to be scheduled at that time, else false
+    def delayed_push(timestamp, item)
+      # First add this item to the list for this timestamp
+      redis.rpush("delayed:#{timestamp.to_i}", Resque.encode(item))
 
-    # Now, add this timestamp to the zsets.  The score and the value are
-    # the same since we'll be querying by timestamp, and we don't have
-    # anything else to store.
-    redis.zadd :delayed_queue_schedule, timestamp.to_i, timestamp.to_i
-  end
-  
-  def delayed_job_to_hash_with_queue(queue, klass, args)
-    {:class => klass.to_s, :args => args, :queue => queue}
+      # Now, add this timestamp to the zsets.  The score and the value are
+      # the same since we'll be querying by timestamp, and we don't have
+      # anything else to store.
+      redis.zadd :delayed_queue_schedule, timestamp.to_i, timestamp.to_i
+    end
+    
+    def delayed_job_to_hash_with_queue(queue, klass, args)
+      {:class => klass.to_s, :args => args, :queue => queue}
+    end
   end
   
-end
+end

data/lib/resque_bus/application.rb

@@ -1,11 +1,16 @@
 module ResqueBus
   class Application
-    attr_reader :app_key, :redis_key
+
+    class << self
     
-    def self.all
-      # note the names arent the same as we started with
-      ResqueBus.redis.smembers(app_list_key).collect{ |val| new(val) }
+      def all
+        # note the names arent the same as we started with
+        ResqueBus.redis.smembers(app_list_key).collect{ |val| new(val) }
+      end
     end
+
+    attr_reader :app_key, :redis_key
+
     
     def initialize(app_key)
       @app_key = self.class.normalize(app_key)

data/lib/resque_bus/dispatch.rb

@@ -2,7 +2,9 @@
 
 module ResqueBus
   class Dispatch
+
     attr_reader :app_key, :subscriptions
+    
     def initialize(app_key)
       @app_key = Application.normalize(app_key)
       @subscriptions = SubscriptionList.new
@@ -18,9 +20,9 @@ module ResqueBus
     
     # allows definitions of other queues
     def method_missing(method_name, *args, &block)
-      if args.size == 1 and block
+      if args.size == 1 && block
         dispatch_event(method_name, args[0], nil, block)
-      elsif args.size == 2 and block
+      elsif args.size == 2 && block
         dispatch_event(method_name, args[0], args[1], block)
       else
         super

data/lib/resque_bus/driver.rb

@@ -2,27 +2,29 @@ module ResqueBus
   # fans out an event to multiple queues
   class Driver
 
-    def self.subscription_matches(attributes)
-      out = []
-      Application.all.each do |app|
-        subs = app.subscription_matches(attributes)
-        out.concat(subs)
+    class << self
+      def subscription_matches(attributes)
+        out = []
+        Application.all.each do |app|
+          subs = app.subscription_matches(attributes)
+          out.concat(subs)
+        end
+        out
       end
-      out
-    end
 
-    def self.perform(attributes={})
-      raise "No attribiutes passed" if attributes.empty?
+      def perform(attributes={})
+        raise "No attribiutes passed" if attributes.empty?
 
-      ResqueBus.log_worker("Driver running: #{attributes.inspect}")
+        ResqueBus.log_worker("Driver running: #{attributes.inspect}")
 
-      subscription_matches(attributes).each do |sub|
-        ResqueBus.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}
-        ResqueBus.enqueue_to(sub.queue_name, sub.class_name, bus_attr.merge(attributes || {}))
+        subscription_matches(attributes).each do |sub|
+          ResqueBus.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}
+          ResqueBus.enqueue_to(sub.queue_name, sub.class_name, bus_attr.merge(attributes || {}))
+        end
       end
     end
 
   end
-end
+end

data/lib/resque_bus/local.rb

@@ -2,30 +2,32 @@ module ResqueBus
   # only process local queues
   class Local
 
-    def self.perform(attributes = {})
-      ResqueBus.log_worker("Local running: #{attributes.inspect}")
+    class << self
+      def perform(attributes = {})
+        ResqueBus.log_worker("Local running: #{attributes.inspect}")
 
-      # 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}
-        to_publish = bus_attr.merge(attributes || {})
-        if ResqueBus.local_mode == :standalone
-          ResqueBus.enqueue_to(sub.queue_name, sub.class_name, bus_attr.merge(attributes || {}))
-        # defaults to inline mode
-        else ResqueBus.local_mode == :inline
-          sub.execute!(to_publish)
+        # 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}
+          to_publish = bus_attr.merge(attributes || {})
+          if ResqueBus.local_mode == :standalone
+            ResqueBus.enqueue_to(sub.queue_name, sub.class_name, bus_attr.merge(attributes || {}))
+          # defaults to inline mode
+          else ResqueBus.local_mode == :inline
+            sub.execute!(to_publish)
+          end
         end
       end
-    end
 
-    # looking directly at subscriptions loaded into dispatcher
-    # so we don't need redis server up
-    def self.subscription_matches(attributes)
-      out = []
-      ResqueBus.dispatchers.each do |dispatcher|
-        out.concat(dispatcher.subscription_matches(attributes))
+      # looking directly at subscriptions loaded into dispatcher
+      # so we don't need redis server up
+      def self.subscription_matches(attributes)
+        out = []
+        ResqueBus.dispatchers.each do |dispatcher|
+          out.concat(dispatcher.subscription_matches(attributes))
+        end
+        out
       end
-      out
     end
 
   end

data/lib/resque_bus/publisher.rb

@@ -1,9 +1,12 @@
 module ResqueBus
   # publishes on a delay
   class Publisher
-    def self.perform(event_type, attributes = {})
-      ResqueBus.log_worker("Publisher running: #{event_type} - #{attributes.inspect}")
-      ResqueBus.publish(event_type, attributes)
+    class << self
+      def perform(event_type, attributes = {})
+        ResqueBus.log_worker("Publisher running: #{event_type} - #{attributes.inspect}")
+        ResqueBus.publish(event_type, attributes)
+      end
     end
+
   end
 end

data/lib/resque_bus/rider.rb

@@ -5,48 +5,50 @@ module ResqueBus
   class Rider
     extend Resque::Plugins::ExponentialBackoff
     
-    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 == ""
+    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 ||= {}
+        
+        ResqueBus.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"]
+        
+        # allow the real Reqsue to be used inside the callback while in a worker
+        Resque.redis = ResqueBus.original_redis if ResqueBus.original_redis
+        
+        # (now running with the real app that subscribed)
+        ResqueBus.dispatcher_execute(app_key, sub_key, attributes.merge("bus_executed_at" => Time.now.to_i))
+      ensure
+        # put this back if running in the thread
+        Resque.redis = ResqueBus.redis if ResqueBus.original_redis
+      end
       
-      attributes ||= {}
+      # @failure_hooks_already_ran on https://github.com/defunkt/resque/tree/1-x-stable
+      # to prevent running twice
+      def queue
+        @my_queue
+      end
       
-      ResqueBus.log_worker("Rider received: #{app_key} #{sub_key} #{attributes.inspect}")
+      def on_failure_aaa(exception, *args)
+        # note: sorted alphabetically
+        # queue needs to be set for rety to work (know what queue in Requeue.class_to_queue)
+        @my_queue = args[0]["bus_rider_queue"]
+      end
       
-      # attributes that should be available
-      # attributes["bus_event_type"]
-      # attributes["bus_app_key"]
-      # attributes["bus_published_at"]
-      # attributes["bus_driven_at"]
-      
-      # allow the real Reqsue to be used inside the callback while in a worker
-      Resque.redis = ResqueBus.original_redis if ResqueBus.original_redis
-      
-      # (now running with the real app that subscribed)
-      ResqueBus.dispatcher_execute(app_key, sub_key, attributes.merge("bus_executed_at" => Time.now.to_i))
-    ensure
-      # put this back if running in the thread
-      Resque.redis = ResqueBus.redis if ResqueBus.original_redis
-    end
-    
-    # @failure_hooks_already_ran on https://github.com/defunkt/resque/tree/1-x-stable
-    # to prevent running twice
-    def self.queue
-      @my_queue
-    end
-    
-    def self.on_failure_aaa(exception, *args)
-      # note: sorted alphabetically
-      # queue needs to be set for rety to work (know what queue in Requeue.class_to_queue)
-      @my_queue = args[0]["bus_rider_queue"]
-    end
-    
-    def self.on_failure_zzz(exception, *args)
-      # note: sorted alphabetically
-      @my_queue = nil
+      def on_failure_zzz(exception, *args)
+        # note: sorted alphabetically
+        @my_queue = nil
+      end
+
     end
-    
   end
 end

data/lib/resque_bus/subscription.rb

@@ -1,29 +1,28 @@
 module ResqueBus
   class Subscription
-    def self.register(queue, key, class_name, matcher, block)
-      Subscription.new(queue, key, class_name, matcher, block)
-    end
-    
-    def self.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
-      Subscription.new(queue_name, key, class_name, matcher, nil)
-    end
-    
-    def to_redis
-      out = {}
-      out["queue_name"] = queue_name
-      out["key"]        = key
-      out["class"]      = class_name
-      out["matcher"]    = matcher.to_redis
-      out
+
+    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
+        Subscription.new(queue_name, key, class_name, matcher, nil)
+      end
+
+      def normalize(val)
+        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
+    
     def initialize(queue_name, key, class_name, filters, executor=nil)
       @queue_name = self.class.normalize(queue_name)
       @key        = key.to_s
@@ -40,11 +39,15 @@ module ResqueBus
     def matches?(attributes)
       @matcher.matches?(attributes)
     end
-    
-    protected
-    
-    def self.normalize(val)
-      val.to_s.gsub(/\W/, "_").downcase
+
+    def to_redis
+      out = {}
+      out["queue_name"] = queue_name
+      out["key"]        = key
+      out["class"]      = class_name
+      out["matcher"]    = matcher.to_redis
+      out
     end
+
   end
 end

data/lib/resque_bus/subscription_list.rb

@@ -1,15 +1,19 @@
 module ResqueBus
   class SubscriptionList
-    def self.from_redis(redis_hash)
-      out = SubscriptionList.new
-      
-      redis_hash.each do |key, value|
-        sub = Subscription.from_redis(value)
-        out.add(sub) if sub
+
+    class << self
+      def from_redis(redis_hash)
+        out = SubscriptionList.new
+        
+        redis_hash.each do |key, value|
+          sub = Subscription.from_redis(value)
+          out.add(sub) if sub
+        end
+
+        out
       end
-      out
     end
-    
+
     def to_redis
       out = {}
       @subscriptions.values.each do |sub|

data/lib/resque_bus/task_manager.rb

@@ -1,6 +1,8 @@
 module ResqueBus
   class TaskManager
+
     attr_reader :logging
+    
     def initialize(logging)
       @logging = logging
     end

data/lib/resque_bus/version.rb

@@ -1,5 +1,5 @@
 module Resque
   module Bus
-    VERSION = "0.2.4"
+    VERSION = "0.2.5"
   end
 end

data/spec/spec_helper.rb

@@ -1,8 +1,6 @@
-require 'rubygems'
-require 'bundler/setup'
 require 'timecop'
-
 require 'resque-bus'
+require 'resque/scheduler'
 
 module ResqueBus
   class Runner

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque-bus
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-13 00:00:00.000000000 Z
+date: 2013-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: resque