resque-bus 0.3.2 → 0.7.0

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/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