resque-bus 0.3.2 → 0.7.0

data/lib/resque_bus/adapter.rb

@@ -0,0 +1,66 @@
+module QueueBus
+  module Adapters
+    class Resque < QueueBus::Adapters::Base
+      def enabled!
+        # know we are using it
+        require 'resque'
+        require 'resque/scheduler'
+        require 'resque-retry'
+
+        QueueBus::Worker.extend(::Resque::Plugins::ExponentialBackoff)
+        QueueBus::Worker.extend(::QueueBus::Adapters::Resque::RetryHandlers)
+      end
+
+      def redis(&block)
+        block.call(::Resque.redis)
+      end
+
+      def enqueue(queue_name, klass, json)
+        ::Resque.enqueue_to(queue_name, klass, json)
+      end
+
+      def enqueue_at(epoch_seconds, queue_name, klass, json)
+        ::Resque.enqueue_at_with_queue(queue_name, epoch_seconds, klass, json)
+      end
+
+      def setup_heartbeat!(queue_name)
+        # turn on the heartbeat
+        # should be down after loading scheduler yml if you do that
+        # otherwise, anytime
+        name     = 'resquebus_heartbeat'
+        schedule = { 'class' => '::QueueBus::Worker',
+                     'args'=>[::QueueBus::Util.encode({'bus_class_proxy' => '::QueueBus::Heartbeat'})],
+                     'cron'  => '* * * * *',   # every minute
+                     'queue' => queue_name,
+                     'description' => 'I publish a heartbeat_minutes event every minute'
+                   }
+        if ::Resque::Scheduler.dynamic
+          ::Resque.set_schedule(name, schedule)
+        end
+        ::Resque.schedule[name] = schedule
+      end
+
+      private
+
+      module RetryHandlers
+        # @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)
+          hash = ::QueueBus::Util.decode(args[0])
+          @my_queue = hash["bus_rider_queue"]
+        end
+
+        def on_failure_zzz(exception, *args)
+          # note: sorted alphabetically
+          @my_queue = nil
+        end
+      end
+    end
+  end
+end

data/lib/resque_bus/compatibility/deprecated.rb

@@ -0,0 +1,38 @@
+module ResqueBus
+  module Deprecated
+    def show_deprecations=val
+      @show_deprecations = val
+    end
+
+    def show_deprecations?
+      return @show_deprecations if defined?(@show_deprecations)
+      return true if !ENV['QUEUES'] && !ENV['QUEUE'] # not in background, probably test
+      return true if ENV['VVERBOSE'] || ENV['LOGGING'] || ENV['VERBOSE']
+      false
+    end
+    
+    def note_deprecation(message)
+      @noted_deprecations ||= {}
+      if @noted_deprecations[message]
+        @noted_deprecations[message] += 1
+      else
+        warn(message) if show_deprecations?
+        @noted_deprecations[message] = 1
+      end
+    end
+
+    def redis
+      ResqueBus.note_deprecation "[DEPRECATION] ResqueBus direct usage is deprecated. Use `QueueBus.redis` instead. Note that it also requires block usage now."
+      ::Resque.redis
+    end
+
+    def redis=val
+      ResqueBus.note_deprecation "[DEPRECATION] ResqueBus can no longer set redis directly. It will use Resque's instance of redis."
+    end
+
+    def method_missing(method_name, *args, &block)
+      ResqueBus.note_deprecation "[DEPRECATION] ResqueBus direct usage is deprecated. Use `QueueBus.#{method_name}` instead."
+      ::QueueBus.send(method_name, *args, &block)
+    end
+  end
+end

data/lib/resque_bus/compatibility/driver.rb

@@ -0,0 +1,10 @@
+module ResqueBus
+  class Driver
+    class << self
+      def perform(attributes={})
+        ResqueBus.note_deprecation "[MIGRATION] Note: new events will be using QueueBus::Driver"
+        ::QueueBus::Driver.perform(attributes)
+      end
+    end
+  end
+end

data/lib/resque_bus/compatibility/heartbeat.rb

@@ -0,0 +1,10 @@
+module ResqueBus
+  class Heartbeat
+    class << self
+      def perform(attributes={})
+        ResqueBus.note_deprecation "[MIGRATION] Note: new events will be using QueueBus::Heartbeat"
+        ::QueueBus::Heartbeat.perform(attributes)
+      end
+    end
+  end
+end

data/lib/resque_bus/compatibility/publisher.rb

@@ -0,0 +1,13 @@
+module ResqueBus
+  # publishes on a delay
+  class Publisher
+    class << self
+      def perform(event_type, attributes = {})
+        attributes["bus_event_type"] = event_type # now using one hash only
+        ResqueBus.note_deprecation "[MIGRATION] Note: new events will be using QueueBus::Publisher"
+        ::QueueBus::Publisher.perform(attributes)
+      end
+    end
+
+  end
+end

data/lib/resque_bus/compatibility/rider.rb

@@ -0,0 +1,32 @@
+require 'resque-retry'
+
+module ResqueBus
+  class Rider
+    extend Resque::Plugins::ExponentialBackoff
+    
+    class << self
+      def perform(attributes = {})
+        ResqueBus.note_deprecation "[MIGRATION] Note: new events will be using QueueBus::Rider"
+        ::QueueBus::Rider.perform(attributes)
+      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

data/lib/resque_bus/compatibility/subscriber.rb

@@ -0,0 +1,8 @@
+module ResqueBus
+  module Subscriber
+    def self.included(base)
+      ResqueBus.note_deprecation "[DEPRECATION] ResqueBus::Subscriber is deprecated. Use QueueBus::Subscriber instead."
+      base.send(:include, ::QueueBus::Subscriber)
+    end
+  end
+end

data/lib/resque_bus/compatibility/task_manager.rb

@@ -0,0 +1,8 @@
+module ResqueBus
+  class TaskManager < ::QueueBus::TaskManager
+    def initialize(logging)
+      ResqueBus.note_deprecation "[DEPRECATION] ResqueBus::TaskManager is deprecated. Use QueueBus::TaskManager instead."
+      super(logging)
+    end
+  end
+end

data/lib/resque_bus/server.rb

@@ -2,7 +2,8 @@ require 'resque-bus'
 require 'resque/server'
 require 'erb'
 
-# Extend Resque::Server to add tabs.
+# MIGRATE TODO: move to resque gem
+# Extend ::Resque::Server to add tabs.
 module ResqueBus
   module Server
 
@@ -15,7 +16,7 @@ module ResqueBus
         
         
         post '/bus/unsubscribe' do
-          app = Application.new(params[:name]).unsubscribe
+          app = ::QueueBus::Application.new(params[:name]).unsubscribe
           redirect u('bus')
         end
         
@@ -24,7 +25,7 @@ module ResqueBus
   end
 end
 
-Resque::Server.tabs << 'Bus'
-Resque::Server.class_eval do
-  include ResqueBus::Server
+::Resque::Server.tabs << 'Bus'
+::Resque::Server.class_eval do
+  include ::ResqueBus::Server
 end

data/lib/resque_bus/server/views/bus.erb

@@ -18,7 +18,7 @@ else
   event_hash = {}
   
   # collect each differently
-  ResqueBus::Application.all.each do |app|
+  ::QueueBus::Application.all.each do |app|
     app_key = app.app_key
     
     app_hash[app_key] ||= []
@@ -61,7 +61,7 @@ else
     else
       one, two, queue, filters = val
       out = "<td>#{h(one)}</td><td>#{h(two)}</td><td><a href='#{u("queues/#{queue}")}'>#{h(queue)}</a></td>"
-      out << "<td>#{h(Resque.encode(filters).gsub(/\"bus_special_value_(\w+)\"/){ "(#{$1})" }).gsub(" ", "&nbsp;").gsub('&quot;,&quot;', '&quot;, &quot;')}</td>"
+      out << "<td>#{h(::QueueBus::Util.encode(filters).gsub(/\"bus_special_value_(\w+)\"/){ "(#{$1})" }).gsub(" ", "&nbsp;").gsub('&quot;,&quot;', '&quot;, &quot;')}</td>"
     end
     
     if first

data/lib/resque_bus/tasks.rb

@@ -1,15 +1,35 @@
-# require 'resquebus/tasks'
-# will give you the resquebus tasks
-
+# require 'resque_bus/tasks'
+# will give you these tasks
 
+require "queue_bus/tasks"
 require "resque/tasks"
+
 namespace :resquebus do
+  # deprecated
+  task :setup => ["queuebus:setup"] do
+    ResqueBus.note_deprecation "[DEPRECATION] rake resquebus:setup is deprecated. Use rake queuebus:setup instead."
+  end
+
+  task :driver => ["queuebus:driver"] do
+    ResqueBus.note_deprecation "[DEPRECATION] rake resquebus:driver is deprecated. Use rake queuebus:driver instead."
+  end
+
+  task :subscribe => ["queuebus:subscribe"] do
+    ResqueBus.note_deprecation "[DEPRECATION] rake resquebus:subscribe is deprecated. Use rake queuebus:subscribe instead."
+  end
+
+  task :unsubsribe => ["queuebus:unsubsribe"] do
+    ResqueBus.note_deprecation "[DEPRECATION] rake resquebus:driver is deprecated. Use rake queuebus:unsubsribe instead."
+  end
+end
+
+namespace :queuebus do
 
   desc "Setup will configure a resque task to run before resque:work"
   task :setup => [ :preload ] do
-    
+
     if ENV['QUEUES'].nil?
-      manager = ::ResqueBus::TaskManager.new(true)
+      manager = ::QueueBus::TaskManager.new(true)
       queues = manager.queue_names
       ENV['QUEUES'] = queues.join(",")
     else
@@ -23,24 +43,9 @@ namespace :resquebus do
     end
   end
 
-  desc "Subscribes this application to ResqueBus events"
-  task :subscribe => [ :preload ] do
-    manager = ::ResqueBus::TaskManager.new(true)
-    count = manager.subscribe!
-    raise "No subscriptions created" if count == 0
-  end
-  
-  desc "Unsubscribes this application from ResqueBus events"
-  task :unsubscribe => [ :preload ] do
-    require 'resque-bus'
-    manager = ::ResqueBus::TaskManager.new(true)
-    count = manager.unsubscribe!
-    puts "No subscriptions unsubscribed" if count == 0
-  end
-  
-  desc "Sets the queue to work the driver  Use: `rake resquebus:driver resque:work`"
+  desc "Sets the queue to work the driver  Use: `rake queuebus:driver resque:work`"
   task :driver => [ :preload ] do
-    ENV['QUEUES'] = "resquebus_incoming"
+    ENV['QUEUES'] = ::QueueBus.incoming_queue
   end
 
   # Preload app files if this is Rails
@@ -50,32 +55,27 @@ namespace :resquebus do
     require "resque/failure/redis"
     require "resque/failure/multiple_with_retry_suppression"
 
-    # change the namespace to be the ones used by ResqueBus
-    # save the old one for handling later
-    ResqueBus.original_redis = Resque.redis
-    Resque.redis = ResqueBus.redis
-    
     Resque::Failure::MultipleWithRetrySuppression.classes = [Resque::Failure::Redis]
     Resque::Failure.backend = Resque::Failure::MultipleWithRetrySuppression
-    
+
     Rake::Task["resque:setup"].invoke # loads the environment and such if defined
   end
-  
-  
+
+
   # examples to test out the system
   namespace :example do
     desc "Publishes events to example applications"
-    task :publish => [ "resquebus:preload", "resquebus:setup" ] do
+    task :publish => [ "queuebus:preload", "queuebus:setup" ] do
       which = ["one", "two", "three", "other"][rand(4)]
-      ResqueBus.publish("event_#{which}", { "rand" => rand(99999)})
-      ResqueBus.publish("event_all", { "rand" => rand(99999)})
-      ResqueBus.publish("none_subscribed", { "rand" => rand(99999)})
+      QueueBus.publish("event_#{which}", { "rand" => rand(99999)})
+      QueueBus.publish("event_all", { "rand" => rand(99999)})
+      QueueBus.publish("none_subscribed", { "rand" => rand(99999)})
       puts "published event_#{which}, event_all, none_subscribed"
     end
-    
+
     desc "Sets up an example config"
-    task :register => [ "resquebus:preload"] do      
-      ResqueBus.dispatch("example") do
+    task :register => [ "queuebus:preload"] do
+      QueueBus.dispatch("example") do
         subscribe "event_one" do
           puts "event1 happened"
         end
@@ -93,14 +93,14 @@ namespace :resquebus do
         end
       end
     end
-    
-    desc "Subscribes this application to ResqueBus example events"
-    task :subscribe => [ :register, "resquebus:subscribe" ]
-    
-    desc "Start a ResqueBus example worker"
-    task :work => [ :register, "resquebus:setup", "resque:work" ]
-    
-    desc "Start a ResqueBus example worker"
-    task :driver => [ :register, "resquebus:driver", "resque:work" ]
+
+    desc "Subscribes this application to QueueBus example events"
+    task :subscribe => [ :register, "queuebus:subscribe" ]
+
+    desc "Start a QueueBus example worker"
+    task :work => [ :register, "queuebus:setup", "resque:work" ]
+
+    desc "Start a QueueBus example worker"
+    task :driver => [ :register, "queuebus:driver", "resque:work" ]
   end
 end

data/lib/resque_bus/version.rb

@@ -1,5 +1,3 @@
-module Resque
-  module Bus
-    VERSION = "0.3.2"
-  end
+module ResqueBus
+  VERSION = "0.7.0"
 end

data/resque-bus.gemspec

@@ -4,30 +4,23 @@ require "resque_bus/version"
 
 Gem::Specification.new do |s|
   s.name        = "resque-bus"
-  s.version     = Resque::Bus::VERSION
+  s.version     = ResqueBus::VERSION
   s.authors     = ["Brian Leonard"]
   s.email       = ["brian@bleonard.com"]
-  s.homepage    = ""
+  s.homepage    = "https://github.com/queue-bus/resque-bus"
   s.summary     = %q{A simple event bus on top of Resque}
-  s.description = %q{A simple event bus on top of Resque.
-    Publish and subscribe to events as they occur through a queue.}
-
-  s.rubyforge_project = "resque-bus"
+  s.description = %q{A simple event bus on top of Resque. Publish and subscribe to events as they occur through a queue.}
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  # specify any dependencies here; for example:
-  # s.add_development_dependency "rspec"
-  # s.add_runtime_dependency "rest-client"
+  s.add_dependency('queue-bus', ['>= 0.7', '< 1'])
   s.add_dependency('resque', ['>= 1.10.0', '< 2.0'])
   s.add_dependency('resque-scheduler', '>= 2.0.1')
   s.add_dependency('resque-retry')
-  s.add_dependency("redis-namespace")
-  s.add_dependency("redis")
-  
+
   s.add_development_dependency("rspec")
   s.add_development_dependency("timecop")
   s.add_development_dependency("json_pure")

data/spec/adapter/compatibility_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe "Compatibility with old resque-bus" do
+  before(:each) do
+    ResqueBus.show_deprecations = false # expected
+
+    QueueBus.dispatch("r1") do
+      subscribe "event_name" do |attributes|
+        QueueBus::Runner1.run(attributes)
+      end
+    end
+
+    QueueBus::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
+
+  describe "Publisher" do
+    it "should still publish as expected" do
+      val = QueueBus.redis { |redis| redis.lpop("queue:resquebus_incoming") }
+      val.should == nil
+      
+      args = [ "event_name", {"bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12} ]
+      item = {:class => "ResqueBus::Publisher", :args => args}
+
+      QueueBus.redis { |redis| redis.sadd(:queues, "resquebus_incoming") }
+      QueueBus.redis { |redis| redis.rpush "queue:resquebus_incoming", Resque.encode(item) }
+
+      QueueBus::Runner1.value.should == 0
+
+      perform_next_job @incoming # publish
+
+      QueueBus::Runner1.value.should == 0
+
+      perform_next_job @new_incoming # drive
+
+      QueueBus::Runner1.value.should == 0
+
+      perform_next_job @rider # ride
+
+      QueueBus::Runner1.value.should == 1
+
+    end
+  end
+
+  describe "Rider" do
+    it "should still ride as expected" do
+      val = QueueBus.redis { |redis| 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}
+
+      QueueBus.redis { |redis| redis.sadd(:queues, "r1_default") }
+      QueueBus.redis { |redis| redis.rpush "queue:r1_default", Resque.encode(item) }
+
+      QueueBus::Runner1.value.should == 0
+
+      perform_next_job @rider
+
+      QueueBus::Runner1.value.should == 1
+    end
+  end
+
+  describe "Driver" do
+    it "should still drive as expected" do
+      val = QueueBus.redis { |redis| redis.lpop("queue:resquebus_incoming") }
+      val.should == nil
+      
+      args = [ {"bus_event_type" => "event_name", "two"=>"here", "one"=>1, "id" => 12} ]
+      item = {:class => "ResqueBus::Driver", :args => args}
+
+      QueueBus.redis { |redis| redis.sadd(:queues, "resquebus_incoming") }
+      QueueBus.redis { |redis| redis.rpush "queue:resquebus_incoming", Resque.encode(item) }
+
+      QueueBus::Runner1.value.should == 0
+
+      perform_next_job @incoming
+
+      QueueBus::Runner1.value.should == 0
+
+      perform_next_job @rider
+
+      QueueBus::Runner1.value.should == 1
+
+    end
+  end
+end