resque-bus 0.3.7 → 0.5.7

data/lib/resque_bus/subscriber.rb

@@ -1,63 +0,0 @@
-module ResqueBus
-  module Subscriber
-    
-    def self.included(base)
-      base.extend ClassMethods
-    end
-    
-    module ClassMethods
-
-      def application(app_key)
-        @app_key = ::ResqueBus::Application.normalize(app_key)
-      end
-      
-      def app_key
-        return @app_key if @app_key
-        @app_key = ::ResqueBus.default_app_key
-        return @app_key if @app_key
-        # module or class_name
-        val = self.name.to_s.split("::").first
-        @app_key = ::ResqueBus::Util.underscore(val)
-      end
-      
-      def subscribe(method_name, matcher_hash = nil)
-        queue_name   = ::Resque.queue_from_class(self)
-        queue_name ||= ::ResqueBus.default_queue
-        queue_name ||= "#{app_key}_default"
-        subscribe_queue(queue_name, method_name, matcher_hash)
-      end
-      
-      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}"
-        dispatcher = ::ResqueBus.dispatcher_by_key(app_key)
-        dispatcher.add_subscription(queue_name, sub_key, klass.name.to_s, matcher_hash, lambda{ |att| klass.perform(att) })
-      end
-      
-      def transform(method_name)
-        @transform = method_name
-      end
-      
-      def perform(attributes)
-        ResqueBus.with_global_attributes(attributes) do
-          sub_key = attributes["bus_rider_sub_key"]
-          meth_key = sub_key.split(".").last
-          resque_bus_execute(meth_key, attributes)
-        end
-      end
-      
-      def resque_bus_execute(key, attributes)
-        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.send(key, *args)
-      end
-    end
-  end
-end

data/lib/resque_bus/subscription.rb

@@ -1,55 +0,0 @@
-module ResqueBus
-  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
-        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
-      @class_name = class_name.to_s
-      @matcher    = Matcher.new(filters)
-      @executor   = executor
-    end
-    
-    def execute!(attributes)
-      attributes = attributes.with_indifferent_access if attributes.respond_to?(:with_indifferent_access)
-      ResqueBus.with_global_attributes(attributes) do
-        executor.call(attributes)
-      end
-    end
-    
-    def matches?(attributes)
-      @matcher.matches?(attributes)
-    end
-
-    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,53 +0,0 @@
-module ResqueBus
-  class SubscriptionList
-
-    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
-    end
-
-    def to_redis
-      out = {}
-      @subscriptions.values.each do |sub|
-        out[sub.key] = sub.to_redis
-      end
-      out
-    end
-    
-    def initialize
-      @subscriptions = {}
-    end
-    
-    def add(sub)
-      @subscriptions[sub.key] = sub
-    end
-    
-    def size
-      @subscriptions.size
-    end
-    
-    def key(key)
-      @subscriptions[key.to_s]
-    end
-    
-    def all
-      @subscriptions.values
-    end
-    
-    def matches(attributes)
-      out = []
-      all.each do |sub|
-        out << sub if sub.matches?(attributes)
-      end
-      out
-    end
-  end
-end

data/lib/resque_bus/task_manager.rb

@@ -1,52 +0,0 @@
-module ResqueBus
-  class TaskManager
-
-    attr_reader :logging
-    
-    def initialize(logging)
-      @logging = logging
-    end
-    
-    def subscribe!
-      count = 0
-      ResqueBus.dispatchers.each do |dispatcher|
-        subscriptions = dispatcher.subscriptions
-        if subscriptions.size > 0
-          count += subscriptions.size
-          log "Subscribing #{dispatcher.app_key} to #{subscriptions.size} subscriptions"
-          app = ResqueBus::Application.new(dispatcher.app_key)
-          app.subscribe(subscriptions, logging)
-          log "  ...done"
-        end
-      end
-      count
-    end
-    
-    def unsubscribe!
-      count = 0
-      ResqueBus.dispatchers.each do |dispatcher|
-        log "Unsubcribing from #{dispatcher.app_key}"
-        app = ResqueBus::Application.new(dispatcher.app_key)
-        app.unsubscribe
-        count += 1
-        log "  ...done"
-      end
-    end
-    
-    def queue_names
-      # let's not talk to redis in here. Seems to screw things up
-      queues = []
-      ResqueBus.dispatchers.each do |dispatcher|
-        dispatcher.subscriptions.all.each do |sub|
-          queues << sub.queue_name
-        end
-      end
-      
-      queues.uniq
-    end
-    
-    def log(message)
-      puts(message) if logging
-    end
-  end
-end

data/lib/resque_bus/util.rb

@@ -1,42 +0,0 @@
-module ResqueBus
-  module Util
-    extend self
-    
-    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.downcase!
-      word
-    end
-    
-    def constantize(camel_cased_word)
-      names = camel_cased_word.split('::')
-      names.shift if names.empty? || names.first.empty?
-
-      names.inject(Object) do |constant, name|
-        if constant == Object
-          constant.const_get(name)
-        else
-          candidate = constant.const_get(name)
-          next candidate if constant.const_defined?(name, false)
-          next candidate unless Object.const_defined?(name)
-
-          # Go down the ancestors to check it it's owned
-          # directly before we reach Object or the end of ancestors.
-          constant = constant.ancestors.inject do |const, ancestor|
-            break const    if ancestor == Object
-            break ancestor if ancestor.const_defined?(name, false)
-            const
-          end
-
-          # owner is in Object, so raise
-          constant.const_get(name, false)
-        end
-      end
-    end
-  end
-end

data/lib/tasks/resquebus.rake

@@ -1,2 +0,0 @@
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
-require 'resque_bus/tasks'

data/spec/compatibility_spec.rb

@@ -1,93 +0,0 @@
-require 'spec_helper'
-
-describe "migration compatibility" do
-  before(:each) do
-    ResqueBus.dispatch("r1") do
-      subscribe "event_name" do |attributes|
-        ResqueBus::Runner1.run(attributes)
-      end
-    end
-
-    ResqueBus::TaskManager.new(false).subscribe!
-    
-    @incoming = Resque::Worker.new(:resquebus_incoming)
-    @incoming.register_worker
-
-    @new_incoming = Resque::Worker.new(:bus_incoming)
-    @new_incoming.register_worker
-
-    @rider = Resque::Worker.new(:r1_default)
-    @rider.register_worker
-  end
-  
-  it "should still drive as expected" do
-    val = ResqueBus.redis.lpop("queue:bus_incoming")
-    val.should == nil
-    
-    args = [ JSON.generate({"bus_class_proxy"=>"QueueBus::Driver", "bus_event_type" => "event_name", "two"=>"here", "one"=>1, "id" => 12}) ]
-    item = {:class => "QueueBus::Worker", :args => args}
-
-    ResqueBus.redis.sadd(:queues, "bus_incoming")
-    ResqueBus.redis.rpush "queue:bus_incoming", Resque.encode(item)
-
-    ResqueBus::Runner1.value.should == 0
-
-    perform_next_job @new_incoming
-
-    ResqueBus::Runner1.value.should == 0
-
-    perform_next_job @rider
-
-    ResqueBus::Runner1.value.should == 1
-  end
-  
-  it "should still ride as expected" do
-    val = ResqueBus.redis.lpop("queue:r1_default")
-    val.should == nil
-
-    args = [ {"bus_rider_app_key"=>"r1", "x" => "y", "bus_event_type" => "event_name", 
-              "bus_rider_sub_key"=>"event_name", "bus_rider_queue" => "default", 
-              "bus_rider_class_name"=>"::ResqueBus::Rider"}]
-    item = {:class => "ResqueBus::Rider", :args => args}
-    
-    args = [ JSON.generate({"bus_class_proxy"=>"QueueBus::Rider","bus_rider_app_key"=>"r1", "x" => "y", 
-                            "bus_event_type" => "event_name", "bus_rider_sub_key"=>"event_name",
-                            "bus_rider_queue" => "default"}) ]
-    item = {:class => "QueueBus::Worker", :args => args}
-
-    ResqueBus.redis.sadd(:queues, "r1_default")
-    ResqueBus.redis.rpush "queue:r1_default", Resque.encode(item)
-
-    ResqueBus::Runner1.value.should == 0
-
-    perform_next_job @rider
-
-    ResqueBus::Runner1.value.should == 1
-  end
-  
-  it "should still publish as expected" do
-    val = ResqueBus.redis.lpop("queue:bus_incoming")
-    val.should == nil
-    
-    args = [ JSON.generate({"bus_class_proxy" => "QueueBus::Publisher", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}) ]
-    item = {:class => "QueueBus::Worker", :args => args}
-
-    ResqueBus.redis.sadd(:queues, "bus_incoming")
-    ResqueBus.redis.rpush "queue:bus_incoming", Resque.encode(item)
-
-    ResqueBus::Runner1.value.should == 0
-
-    perform_next_job @new_incoming # publish
-
-    ResqueBus::Runner1.value.should == 0
-
-    perform_next_job @incoming # drive
-
-    ResqueBus::Runner1.value.should == 0
-
-    perform_next_job @rider # ride
-
-    ResqueBus::Runner1.value.should == 1
-    
-  end
-end

data/spec/publish_at_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-describe "Publishing an event in the future" do
-  
-  before(:each) do
-    Timecop.freeze(now)
-    ResqueBus.stub(:generate_uuid).and_return("idfhlkj")
-  end
-  after(:each) do
-    Timecop.return
-  end
-  let(:delayed_attrs) { {"bus_delayed_until" => future.to_i,
-                     "bus_id" => "#{now.to_i}-idfhlkj",
-                     "bus_app_hostname" =>  `hostname 2>&1`.strip.sub(/.local/,'')} }
-  
-  let(:bus_attrs) { delayed_attrs.merge({"bus_published_at" => worktime.to_i})}
-  let(:now)    { Time.parse("01/01/2013 5:00")}                   
-  let(:future) { Time.at(now.to_i + 60) }
-  let(:worktime) {Time.at(future.to_i + 1)}
-  
-  it "should add it to Redis" do
-    hash = {:one => 1, "two" => "here", "id" => 12 }
-    event_name = "event_name"
-    ResqueBus.publish_at(future, event_name, hash)
-    
-    schedule = ResqueBus.redis.zrange("delayed_queue_schedule", 0, 1)
-    schedule.should == [future.to_i.to_s]
-    
-    val = ResqueBus.redis.lpop("delayed:#{future.to_i}")
-    hash = JSON.parse(val)
-
-    hash["class"].should == "ResqueBus::Publisher"
-    hash["args"].should == [ "event_name", {"bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_attrs) ]
-    hash["queue"].should == "resquebus_incoming"
-  end
-
-  it "should move it to the real queue when processing" do
-    hash = {:one => 1, "two" => "here", "id" => 12 }
-    event_name = "event_name"
-    
-    val = ResqueBus.redis.lpop("queue:resquebus_incoming")
-    val.should == nil
-    
-    ResqueBus.publish_at(future, event_name, hash)
-    
-    val = ResqueBus.redis.lpop("queue:resquebus_incoming")
-    val.should == nil # nothing really added
-    
-    # process sceduler now
-    Resque::Scheduler.handle_delayed_items
-    
-    val = ResqueBus.redis.lpop("queue:resquebus_incoming")
-    val.should == nil # nothing added yet
-    
-    # process scheduler in future
-    Timecop.freeze(worktime) do
-      Resque::Scheduler.handle_delayed_items
-      
-      # added
-      val = ResqueBus.redis.lpop("queue:resquebus_incoming")
-      hash = JSON.parse(val)
-      hash["class"].should == "ResqueBus::Publisher"
-      hash["args"].should == [ "event_name", {"bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_attrs) ]
-      
-     ResqueBus::Publisher.perform(*hash["args"])
-     
-     val = ResqueBus.redis.lpop("queue:resquebus_incoming")
-     hash = JSON.parse(val)
-     hash["class"].should == "ResqueBus::Driver"
-     hash["args"].should == [ {"bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(bus_attrs) ]
-    end
-  end
-
-end

data/spec/redis_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe "Redis Connection" do
-  it "should use the one specified if given" do
-    ResqueBus.redis = "localhost:9379"
-    ResqueBus.redis.instance_variable_get("@redis").client.port.should == 9379
-    Resque.redis.instance_variable_get("@redis").client.port.should == 6379
-  end
-  it "should use the default Resque connection if none specified" do
-    ResqueBus.redis.instance_variable_get("@redis").client.port.should == 6379
-    Resque.redis.instance_variable_get("@redis").client.port.should == 6379
-  end
-end