resque-bus 0.3.7 → 0.5.7

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque-bus
 version: !ruby/object:Gem::Version
-  version: 0.3.7
+  version: 0.5.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-12 00:00:00.000000000 Z
+date: 2015-03-31 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: queue-bus
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.5
 - !ruby/object:Gem::Dependency
   name: resque
   requirement: !ruby/object:Gem::Requirement
@@ -65,38 +81,6 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: redis-namespace
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: redis
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -145,8 +129,8 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: ! "A simple event bus on top of Resque.\n    Publish and subscribe to
-  events as they occur through a queue."
+description: A simple event bus on top of Resque. Publish and subscribe to events
+  as they occur through a queue.
 email:
 - brian@bleonard.com
 executables: []
@@ -162,42 +146,41 @@ files:
 - README.mdown
 - Rakefile
 - lib/resque-bus.rb
-- lib/resque_bus/application.rb
-- lib/resque_bus/compatibility.rb
-- lib/resque_bus/dispatch.rb
-- lib/resque_bus/driver.rb
-- lib/resque_bus/heartbeat.rb
-- lib/resque_bus/local.rb
-- lib/resque_bus/matcher.rb
-- lib/resque_bus/publisher.rb
-- lib/resque_bus/rider.rb
+- lib/resque_bus/adapter.rb
+- lib/resque_bus/compatibility/deprecated.rb
+- lib/resque_bus/compatibility/driver.rb
+- lib/resque_bus/compatibility/heartbeat.rb
+- lib/resque_bus/compatibility/publisher.rb
+- lib/resque_bus/compatibility/rider.rb
+- lib/resque_bus/compatibility/subscriber.rb
+- lib/resque_bus/compatibility/task_manager.rb
 - lib/resque_bus/server.rb
 - lib/resque_bus/server/views/bus.erb
-- lib/resque_bus/subscriber.rb
-- lib/resque_bus/subscription.rb
-- lib/resque_bus/subscription_list.rb
-- lib/resque_bus/task_manager.rb
 - lib/resque_bus/tasks.rb
-- lib/resque_bus/util.rb
 - lib/resque_bus/version.rb
-- lib/tasks/resquebus.rake
 - resque-bus.gemspec
+- spec/adapter/compatibility_spec.rb
+- spec/adapter/integration_spec.rb
+- spec/adapter/publish_at_spec.rb
+- spec/adapter/retry_spec.rb
+- spec/adapter/support.rb
+- spec/adapter_spec.rb
 - spec/application_spec.rb
-- spec/compatibility_spec.rb
+- spec/config_spec.rb
 - spec/dispatch_spec.rb
 - spec/driver_spec.rb
 - spec/heartbeat_spec.rb
 - spec/integration_spec.rb
 - spec/matcher_spec.rb
-- spec/publish_at_spec.rb
 - spec/publish_spec.rb
-- spec/redis_spec.rb
+- spec/publisher_spec.rb
 - spec/rider_spec.rb
 - spec/spec_helper.rb
 - spec/subscriber_spec.rb
 - spec/subscription_list_spec.rb
 - spec/subscription_spec.rb
-homepage: ''
+- spec/worker_spec.rb
+homepage: https://github.com/queue-bus/resque-bus
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -222,19 +205,25 @@ signing_key:
 specification_version: 3
 summary: A simple event bus on top of Resque
 test_files:
+- spec/adapter/compatibility_spec.rb
+- spec/adapter/integration_spec.rb
+- spec/adapter/publish_at_spec.rb
+- spec/adapter/retry_spec.rb
+- spec/adapter/support.rb
+- spec/adapter_spec.rb
 - spec/application_spec.rb
-- spec/compatibility_spec.rb
+- spec/config_spec.rb
 - spec/dispatch_spec.rb
 - spec/driver_spec.rb
 - spec/heartbeat_spec.rb
 - spec/integration_spec.rb
 - spec/matcher_spec.rb
-- spec/publish_at_spec.rb
 - spec/publish_spec.rb
-- spec/redis_spec.rb
+- spec/publisher_spec.rb
 - spec/rider_spec.rb
 - spec/spec_helper.rb
 - spec/subscriber_spec.rb
 - spec/subscription_list_spec.rb
 - spec/subscription_spec.rb
+- spec/worker_spec.rb
 has_rdoc: 

data/lib/resque_bus/application.rb

@@ -1,115 +0,0 @@
-module ResqueBus
-  class Application
-
-    class << self
-    
-      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)
-      @redis_key = "#{self.class.app_single_key}:#{@app_key}"
-      # raise error if only other chars
-      raise "Invalid application name" if @app_key.gsub("_", "").size == 0
-    end
-    
-    def subscribe(subscription_list, log = false)
-      @subscriptions = nil
-      
-      if subscription_list == nil || subscription_list.size == 0
-        unsubscribe
-        return true
-      end
-      
-      temp_key = "temp_#{redis_key}:#{rand(999999999)}"
-      
-      redis_hash = subscription_list.to_redis
-      redis_hash.each do |key, hash|
-        ResqueBus.redis.hset(temp_key, key, Resque.encode(hash))
-      end
-      
-      # make it the real one
-      ResqueBus.redis.rename(temp_key, redis_key)
-      ResqueBus.redis.sadd(self.class.app_list_key, app_key)
-      
-      if log
-        puts ResqueBus.redis.hgetall(redis_key).inspect
-      end
-      
-      true
-    end
-        
-    def unsubscribe
-      # TODO: clean up known queues?
-      ResqueBus.redis.srem(self.class.app_list_key, app_key)
-      ResqueBus.redis.del(redis_key)
-    end
-    
-    def no_connect_queue_names_for(subscriptions)
-      out = []
-      subscriptions.all.each do |sub|
-        queue = "#{app_key}_#{sub.queue_name}"
-        out << queue
-      end
-      out << "#{app_key}_default"
-      out.uniq
-    end
-    
-    def subscription_matches(attributes)
-      out = subscriptions.matches(attributes)
-      out.each do |sub|
-        sub.app_key = self.app_key
-      end
-      out
-    end
-    
-    def event_display_tuples
-      out = []
-      subscriptions.all.each do |sub|
-        out << [sub.class_name, sub.queue_name, sub.matcher.filters]
-      end
-      out
-    end
-    
-    protected
-
-    def self.normalize(val)
-      val.to_s.gsub(/\W/, "_").downcase
-    end
-    
-    def self.app_list_key
-      "resquebus_apps"
-    end
-    
-    def self.app_single_key
-      "resquebus_app"
-    end
-    
-    def event_queues
-      ResqueBus.redis.hgetall(redis_key)
-    end
-    
-    def subscriptions
-      @subscriptions ||= SubscriptionList.from_redis(read_redis_hash)
-    end
-    
-    def read_redis_hash
-      out = {}
-      ResqueBus.redis.hgetall(redis_key).each do |key, val|
-        begin
-          out[key] = Resque.decode(val)
-        rescue Resque::Helpers::DecodeException
-          out[key] = val
-        end
-      end
-      out
-    end
-   
-  end
-end

data/lib/resque_bus/compatibility.rb

@@ -1,24 +0,0 @@
-# these can be in the queue from the new queue-bus version
-module QueueBus
-  class Worker
-
-    def self.perform(json)
-      attributes = ::Resque.decode(json)
-      class_name = attributes["bus_class_proxy"]
-      
-      case class_name
-      when "::QueueBus::Driver", "QueueBus::Driver"
-        ResqueBus::Driver.perform(attributes)
-      when "::QueueBus::Rider", "QueueBus::Rider"
-        ResqueBus::Rider.perform(attributes)
-      when "::QueueBus::Publisher", "QueueBus::Publisher"
-        ResqueBus::Publisher.perform(attributes["bus_event_type"], attributes)
-      when "::QueueBus::Heartbeat", "QueueBus::Heartbeat"
-        ResqueBus::Heartbeat.perform
-      else
-        klass = ::ResqueBus::Util.constantize(class_name)
-        klass.perform(attributes)
-      end
-    end
-  end
-end

data/lib/resque_bus/dispatch.rb

@@ -1,61 +0,0 @@
-# Creates a DSL for apps to define their blocks to run for event_types
-
-module ResqueBus
-  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)
-    end
-    
-    # allows definitions of other queues
-    def method_missing(method_name, *args, &block)
-      if args.size == 1 && block
-        dispatch_event(method_name, args[0], nil, block)
-      elsif args.size == 2 && block
-        dispatch_event(method_name, args[0], args[1], block)
-      else
-        super
-      end
-    end
-    
-    def execute(key, attributes)
-      sub = subscriptions.key(key)
-      if sub
-        sub.execute!(attributes)
-      else
-        # TODO: log that it's not there
-      end
-    end
-
-    def subscription_matches(attributes)
-      out = subscriptions.matches(attributes)
-      out.each do |sub|
-        sub.app_key = self.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, "::ResqueBus::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)
-      sub
-    end
-  end
-end

data/lib/resque_bus/driver.rb

@@ -1,30 +0,0 @@
-module ResqueBus
-  # fans out an event to multiple queues
-  class Driver
-
-    class << self
-      def subscription_matches(attributes)
-        out = []
-        Application.all.each do |app|
-          subs = app.subscription_matches(attributes)
-          out.concat(subs)
-        end
-        out
-      end
-
-      def perform(attributes={})
-        raise "No attributes passed" if attributes.empty?
-
-        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 || {}))
-        end
-      end
-    end
-
-  end
-end

data/lib/resque_bus/heartbeat.rb

@@ -1,106 +0,0 @@
-module ResqueBus
-  # publishes event about the current time
-  class Heartbeat
-
-    class << self
-      
-      def lock_key
-        "resquebus:heartbeat:lock"
-      end
-      
-      def lock_seconds
-        60
-      end
-      
-      def lock!
-        now = Time.now.to_i
-        timeout = now + lock_seconds + 2
-
-        # return true if we successfully acquired the lock
-        return timeout if Resque.redis.setnx(lock_key, timeout)
-
-        # see if the existing timeout is still valid and return false if it is
-        # (we cannot acquire the lock during the timeout period)
-        return 0 if now <= Resque.redis.get(lock_key).to_i
-
-        # otherwise set the timeout and ensure that no other worker has
-        # acquired the lock
-        if now > Resque.redis.getset(lock_key, timeout).to_i
-          return timeout
-        else
-          return 0
-        end
-      end
-      
-      def unlock!
-        Resque.redis.del(lock_key)
-      end
-      
-      
-      def redis_key
-        "resquebus:heartbeat:timestamp"
-      end
-
-      def environment_name
-        ENV["RAILS_ENV"] || ENV["RACK_ENV"] || ENV["RESQUEBUS_ENV"]
-      end
-      
-      def get_saved_minute!
-        key = ResqueBus.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
-          key = three_ago if key.to_i < three_ago
-        end
-        return key.to_i
-      end
-
-      def set_saved_minute!(epoch_minute)
-        ResqueBus.redis.set(redis_key, epoch_minute)
-      end
-      
-      def perform
-        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)
-          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)
-
-          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
-
-          ResqueBus.publish("heartbeat_minutes", attributes)
-          set_saved_minute!(minutes)
-        end
-
-        unlock!
-      end
-    end
-
-  end
-end

data/lib/resque_bus/local.rb

@@ -1,38 +0,0 @@
-module ResqueBus
-  # only process local queues
-  class Local
-
-    class << self
-      def perform(attributes = {})
-        if ResqueBus.local_mode == :suppress
-          ResqueBus.log_worker("Suppressed: #{attributes.inspect}")
-          return  # not doing anything
-        end
-
-        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 || {}))
-          else  # defaults to inline mode
-            sub.execute!(to_publish)
-          end
-        end
-      end
-
-      # looking directly at subscriptions loaded into dispatcher
-      # so we don't need redis server up
-      def subscription_matches(attributes)
-        out = []
-        ResqueBus.dispatchers.each do |dispatcher|
-          out.concat(dispatcher.subscription_matches(attributes))
-        end
-        out
-      end
-    end
-
-  end
-end

data/lib/resque_bus/matcher.rb

@@ -1,81 +0,0 @@
-module ResqueBus
-  class Matcher
-    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
-      
-      given = attributes[attribute_name]
-      case mine
-      when "#{SPECIAL_PREPEND}key"
-        return true if attributes.has_key?(attribute_name)
-        return false
-      when "#{SPECIAL_PREPEND}blank"
-        return true if given.to_s.strip.size == 0
-        return false
-      when "#{SPECIAL_PREPEND}empty"
-        return false if given == nil
-        return true if given.to_s.size == 0
-        return false
-      when "#{SPECIAL_PREPEND}nil"
-        return true if given == nil
-        return false
-      when "#{SPECIAL_PREPEND}value"
-        return false if given == nil
-        return true
-      when "#{SPECIAL_PREPEND}present"
-        return true if given.to_s.strip.size > 0
-        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
-        return !!regex.match(given)
-      rescue
-        return false
-      end
-    end
-    
-    def matches?(attributes)
-      return false if filters.empty?
-      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|
-        case value
-        when :key, :blank, :nil, :present, :empty, :value
-          value = "#{SPECIAL_PREPEND}#{value}"
-        end
-        out[key.to_s] = value.to_s
-      end      
-      out
-    end
-  end
-end
-

data/lib/resque_bus/publisher.rb

@@ -1,12 +0,0 @@
-module ResqueBus
-  # publishes on a delay
-  class Publisher
-    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

@@ -1,54 +0,0 @@
-require 'resque-retry'
-
-module ResqueBus
-  # queue'd in each
-  class Rider
-    extend Resque::Plugins::ExponentialBackoff
-    
-    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
-      
-      # @failure_hooks_already_ran on https://github.com/defunkt/resque/tree/1-x-stable
-      # to prevent running twice
-      def queue
-        @my_queue
-      end
-      
-      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
-      
-      def on_failure_zzz(exception, *args)
-        # note: sorted alphabetically
-        @my_queue = nil
-      end
-
-    end
-  end
-end