multi_worker 0.1.0

data/lib/multi_worker.rb

@@ -0,0 +1,79 @@
+require "multi_worker/version"
+require "multi_worker/interface"
+
+module MultiWorker
+  @adapters = {}
+  @default_queue = :default
+
+  AdapterNames = [
+    :resque,
+    :sidekiq,
+    :delayed_job,
+    :qu,
+    :queue_classic,
+    :que,
+    :sneakers,
+    :torquebox_backgroundable,
+    :threaded_in_memory_queue,
+    :sucker_punch,
+    :backburner,
+    :inline
+  ]
+
+  class << self
+    def enqueue(worker_klass, *args)
+      worker_klass.perform_async(*args)
+    end
+
+    def configure(&block)
+      instance_eval &block
+    end
+
+    def default_options(opts={})
+      @default_options ||= {
+        :adapter => default_adapter,
+        :queue => default_queue,
+        :status => false,
+        :retry => false,
+        :lock => false,
+        :unique => false
+      }
+
+      if opts && !opts.empty?
+        @default_options.merge!(opts)
+      end
+
+      @default_options
+    end
+
+    attr_accessor :default_queue
+
+    def default_adapter(adapter_name=nil)
+      return (@default_adapter = adapter_name) if (adapter_name && !adapter_name.empty?)
+
+      @default_adapter ||= case
+        when defined?(::Resque) then :resque
+        when defined?(::Sidekiq) then :sidekiq
+        when defined?(::Delayed::Worker) then :delayed_job
+        when defined?(::Qu) then :qu
+        when defined?(::QC::Queue) then :queue_classic
+        when defined?(::Que) then :que
+        when defined?(::Sneakers::Worker) then :sneakers
+        when defined?(::TorqueBox::Messaging::Backgroundable) then :torquebox_backgroundable
+        when defined?(::ThreadedInMemoryQueue) then :threaded_in_memory_queue
+        when defined?(::SuckerPunch::Job) then :sucker_punch
+        when defined?(::Backburner) then :backburner
+        else :inline
+      end
+    end
+
+    def adapter(adapter_name=nil)
+      adapter_name ||= default_adapter
+      @adapters[adapter_name] ||= begin
+        require "multi_worker/adapters/#{adapter_name}"
+        klass_name = adapter_name.to_s.split('_').map(&:capitalize) * ''
+        MultiWorker::Adapters.const_get(klass_name)
+      end
+    end
+  end
+end

data/multi_worker.gemspec

@@ -0,0 +1,56 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'multi_worker/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "multi_worker"
+  spec.version       = MultiWorker::VERSION
+  spec.authors       = ["David Butler"]
+  spec.email         = ["dwbutler@ucla.edu"]
+  spec.summary       = %q{Provides a common interface to Ruby worker/queue libraries.}
+  spec.description   = %q{Provides a common interface to Ruby worker/queue libraries.}
+  spec.homepage      = "https://github.com/dwbutler/multi_worker"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+
+  spec.add_development_dependency "resque"
+  spec.add_development_dependency "resque-retry"
+  spec.add_development_dependency "resque-status"
+  spec.add_development_dependency "resque-loner"
+  spec.add_development_dependency "resque-lock-timeout"
+  spec.add_development_dependency "resque-delay"
+
+  spec.add_development_dependency "sidekiq"
+  spec.add_development_dependency "sidekiq-lock"
+  spec.add_development_dependency "sidekiq_status"
+  spec.add_development_dependency "sidekiq-unique-jobs"
+  spec.add_development_dependency "sidekiq-delay"
+
+  spec.add_development_dependency "delayed_job"
+  spec.add_development_dependency "delayed_job_active_record"
+
+  spec.add_development_dependency "qu", "0.2.0"
+
+  spec.add_development_dependency "queue_classic" unless (RUBY_ENGINE == "jruby")
+  
+  spec.add_development_dependency "que"
+
+  spec.add_development_dependency "sneakers"
+
+  spec.add_development_dependency "threaded_in_memory_queue"
+
+  spec.add_development_dependency "sucker_punch"
+
+  spec.add_development_dependency "backburner"
+
+  spec.add_development_dependency "torquebox-messaging" if (RUBY_ENGINE == "jruby")
+end

data/spec/adapters/backburner_spec.rb

@@ -0,0 +1,32 @@
+require 'backburner'
+require 'test_workers'
+
+describe TestWorker do
+  it_behaves_like "a worker"
+
+  it { should be_a ::Backburner::Queue }
+end
+
+describe MultiWorker do
+  context "when Backburner is loaded" do
+    it "defaults to the :backburner adapter" do
+      MultiWorker.default_adapter.should == :backburner
+    end
+  end
+
+  context "when using the :backburner adapter" do
+    it "::perform_async uses Backburner" do
+      Backburner.should_receive(:enqueue).once.with(TestWorker, "foo")
+      TestWorker.perform_async("foo")
+    end
+
+    it "MultiWorker.enqueue uses Backburner" do
+      Backburner.should_receive(:enqueue).once.with(TestWorker, "foo")
+      MultiWorker.enqueue(TestWorker, "foo")
+    end
+
+    it "exposes the Backburner rake task" do
+      MultiWorker.adapter.rake_task.name.should == "backburner:work"
+    end
+  end
+end

data/spec/adapters/delayed_job_spec.rb

@@ -0,0 +1,32 @@
+require 'delayed_job'
+require 'delayed/backend/test'
+Delayed::Worker.backend = :test
+#require 'delayed_job_active_record'
+Delayed::Worker.delay_jobs = false
+
+require 'test_workers'
+
+describe TestWorker do
+  it_behaves_like "a worker"
+end
+
+describe MultiWorker do
+  context "when Delayed::Job is loaded" do
+    it "defaults to the :delayed_job adapter" do
+      MultiWorker.default_adapter.should == :delayed_job
+    end
+  end
+
+  context "when using the :delayed_job adapter" do
+    it "performs the work using Delayed::Job" do
+      expect(TestWorker).to receive(:perform).exactly(3).times.with("foo")
+      TestWorker.perform_async("foo")
+      MultiWorker.enqueue(TestWorker, "foo")
+      TestWorker.perform("foo")
+    end
+
+    it "exposes the Delayed Job rake task" do
+      MultiWorker.adapter.rake_task.name.should == "jobs:work"
+    end
+  end
+end

data/spec/adapters/inline_spec.rb

@@ -0,0 +1,18 @@
+require 'test_workers'
+
+describe MultiWorker do
+  context "when no other adapter is available" do
+    it "defaults to the :inline adapter" do
+      MultiWorker.default_adapter.should == :inline
+    end
+  end
+
+  context "when using the :inline adapter" do
+    it "performs the work immediately" do
+      expect(TestWorker).to receive(:perform).exactly(3).times.with("foo")
+      TestWorker.perform_async("foo")
+      MultiWorker.enqueue(TestWorker, "foo")
+      TestWorker.perform("foo")
+    end
+  end
+end

data/spec/adapters/qu_spec.rb

@@ -0,0 +1,29 @@
+require 'qu'
+require 'qu-immediate'
+
+require 'test_workers'
+
+describe TestWorker do
+  it_behaves_like "a worker"
+end
+
+describe MultiWorker do
+  context "when Qu is loaded" do
+    it "defaults to the :qu adapter" do
+      MultiWorker.default_adapter.should == :qu
+    end
+  end
+
+  context "when using the :qu adapter" do
+    it "performs the work using Qu's backend" do
+      expect(TestWorker).to receive(:perform).exactly(3).times.with("foo")
+      TestWorker.perform_async("foo")
+      MultiWorker.enqueue(TestWorker, "foo")
+      TestWorker.perform("foo")
+    end
+
+    it "exposes the Qu rake task" do
+      MultiWorker.adapter.rake_task.name.should == "qu:work"
+    end
+  end
+end

data/spec/adapters/que_spec.rb

@@ -0,0 +1,44 @@
+require 'que'
+require 'active_record'
+::Que.mode = :sync
+
+require 'test_workers'
+
+describe TestWorker do
+  it_behaves_like "a worker"
+
+  it { TestWorker::Job.should be < ::Que::Job }
+end
+
+describe MultiWorker do
+  context "when Que is loaded" do
+    it "defaults to the :que adapter" do
+      MultiWorker.default_adapter.should == :que
+    end
+  end
+
+  context "when using the :que adapter" do
+    before(:each) do
+      Que::Job.any_instance.stub(:destroy => true)
+    end
+
+    it "forwards ::perform to #perform" do
+      expect_any_instance_of(TestWorker).to receive(:perform).once.with("foo")
+      TestWorker.perform("foo")
+    end
+
+    it "::perform_async performs the work using Que" do
+      expect_any_instance_of(TestWorker).to receive(:perform).once
+      TestWorker.perform_async("foo")
+    end
+
+    it "MultiWorker.enqueue performs the work using Que" do
+      expect_any_instance_of(TestWorker).to receive(:perform).once
+      MultiWorker.enqueue(TestWorker, "foo")
+    end
+
+    it "exposes the Que rake task" do
+      MultiWorker.adapter.rake_task.name.should == "que:work"
+    end
+  end
+end

data/spec/adapters/queue_classic_spec.rb

@@ -0,0 +1,41 @@
+exit if jruby?
+
+ENV["DATABASE_URL"] ||= "postgres:///queue_classic_test"
+require 'queue_classic'
+
+module QC
+  class Queue
+    def enqueue(method, *args)
+      klass = eval(method.split(".").first)
+      message = method.split(".").last
+      klass.send(message, *args)
+    end
+  end
+end
+
+require 'test_workers'
+
+describe TestWorker do
+  it_behaves_like "a worker"
+end
+
+describe MultiWorker do
+  context "when Queue Classic is loaded" do
+    it "defaults to the :queue_classic adapter" do
+      MultiWorker.default_adapter.should == :queue_classic
+    end
+  end
+
+  context "when using the :queue_classic adapter" do
+    it "performs the work using Queue Classic" do
+      expect(TestWorker).to receive(:perform).exactly(3).times.with("foo")
+      TestWorker.perform_async("foo")
+      MultiWorker.enqueue(TestWorker, "foo")
+      TestWorker.perform("foo")
+    end
+
+    it "exposes the Queue Classic rake task" do
+      MultiWorker.adapter.rake_task.name.should == "qc:work"
+    end
+  end
+end

data/spec/adapters/resque_spec.rb

@@ -0,0 +1,74 @@
+require 'resque'
+Resque.inline = true
+
+require 'test_workers'
+
+describe TestWorker do
+  it_behaves_like "a worker"
+end
+
+describe MultiWorker do
+  context "when Resque is loaded" do
+    it "defaults to the :resque adapter" do
+      MultiWorker.default_adapter.should == :resque
+    end
+  end
+
+  context "when using the :resque adapter" do
+    it "performs the work using Resque" do
+      expect(TestWorker).to receive(:perform).exactly(3).times.with("foo")
+      TestWorker.perform_async("foo")
+      MultiWorker.enqueue(TestWorker, "foo")
+      TestWorker.perform("foo")
+    end
+
+    context "with advanced options" do
+      it "configures :retry option" do
+        retry_worker = Class.new do
+          worker :retry => {:limit => 10, :delay => 5 }
+        end
+
+        retry_worker.should be_a ::Resque::Plugins::Retry
+        retry_worker.instance_variable_get(:@retry_limit).should == 10
+        retry_worker.instance_variable_get(:@retry_delay).should == 5
+      end
+
+      it "configures :lock option" do
+        locking_worker = Class.new do
+          worker :lock => {:timeout => 5}
+        end
+
+        locking_worker.should be_a ::Resque::Plugins::LockTimeout
+        locking_worker.instance_variable_get(:@lock_timeout).should == 5
+      end
+
+      it "configures :unique option with :lock" do
+        unique_worker = Class.new do
+          worker :lock => true, :unique => true
+        end
+
+        unique_worker.instance_variable_get(:@loner).should be_true
+      end
+
+      it "configures :unique option without :lock" do
+        unique_worker = Class.new do
+          worker :unique => true
+        end
+
+        unique_worker.should include ::Resque::Plugins::UniqueJob
+      end
+
+      it "configures :status option" do
+        status_worker = Class.new do
+          worker :status => true
+        end
+
+        status_worker.should include ::Resque::Plugins::Status
+      end
+    end
+
+    it "exposes the Resque rake task" do
+      MultiWorker.adapter.rake_task.name.should == "resque:work"
+    end
+  end
+end

data/spec/adapters/sidekiq_spec.rb

@@ -0,0 +1,91 @@
+require 'sidekiq'
+require 'sidekiq/testing'
+::Sidekiq::Testing.fake!
+
+require 'test_workers'
+
+describe TestWorker do
+  it_behaves_like "a worker"
+
+  it { should be_a ::Sidekiq::Worker }
+end
+
+describe MultiWorker do
+  context "when Sidekiq is loaded" do
+    it "defaults to the :sidekiq adapter" do
+      MultiWorker.default_adapter.should == :sidekiq
+    end
+  end
+
+  context "when using the :sidekiq adapter" do
+    it "performs the work using Sidekiq" do
+      TestWorker.perform_async("foo")
+      MultiWorker.enqueue(TestWorker, "foo")
+      TestWorker.jobs.size.should == 2
+    end
+
+    it "forwards ::perform to #perform" do
+      expect(TestWorker).to receive(:perform).once.with("foo")
+      TestWorker.perform("foo")
+    end
+
+    context "with advanced options" do
+      context "when configuring the :retry option" do
+        context "with a hash" do
+          it "configures limit and delay" do
+            retry_worker = Class.new do
+              worker :retry => {:limit => 10, :delay => lambda {|count| count*5} }
+            end
+
+            retry_worker.get_sidekiq_options['retry'].should == 10
+            retry_worker.sidekiq_retry_in_block.call(3).should == 15
+          end
+        end
+
+        context "with a number" do
+          it "configures limit" do
+            retry_worker = Class.new do
+              worker :retry => 15
+            end
+
+            retry_worker.get_sidekiq_options['retry'].should == 15
+          end
+        end
+
+        context "with a boolean" do
+          it "configures retry" do
+            retry_worker = Class.new do
+              worker :retry => true
+            end
+
+            retry_worker.get_sidekiq_options['retry'].should == true
+          end
+        end
+      end
+
+      it "configures :lock option" do
+        locking_worker = Class.new do
+          worker :lock => true
+        end
+
+        locking_worker.get_sidekiq_options['lock'].should == true
+      end
+
+      it "configures :unique option" do
+        unique_worker = Class.new do
+          worker :unique => true
+        end
+
+        unique_worker.get_sidekiq_options['unique'].should == true
+      end
+
+      it "configures :status option" do
+        status_worker = Class.new do
+          worker :status => true
+        end
+
+        status_worker.new.should be_a ::SidekiqStatus::Worker
+      end
+    end
+  end
+end

data/spec/adapters/sneakers_spec.rb

@@ -0,0 +1,36 @@
+require 'sneakers'
+Sneakers.configure(:env => 'test')
+
+require 'test_workers'
+
+describe TestWorker do
+  it_behaves_like "a worker"
+
+  it { should be_a ::Sneakers::Worker }
+end
+
+describe MultiWorker do
+  context "when Sneakers is loaded" do
+    it "defaults to the :qu adapter" do
+      MultiWorker.default_adapter.should == :sneakers
+    end
+  end
+
+  context "when using the :sneakers adapter" do
+    let(:worker) { TestWorker.new }
+
+    context "when calling #perform_async" do
+      it "publishes a message to the queue" do
+        expect(::Sneakers).to receive(:publish).once
+        worker.perform_async("foo")
+      end
+    end
+
+    context "when Sneakers calls #work" do
+      it "calls #perform" do
+        expect(worker).to receive(:perform).once.with("foo")
+        worker.work(["foo"].to_json)
+      end
+    end
+  end
+end

data/spec/adapters/sucker_punch_spec.rb

@@ -0,0 +1,36 @@
+require 'sucker_punch'
+require 'sucker_punch/testing/inline'
+
+require 'test_workers'
+
+describe TestWorker do
+  it_behaves_like "a worker"
+
+  it { should be_a ::SuckerPunch::Job }
+end
+
+describe MultiWorker do
+  context "when Sucker Punch is loaded" do
+    it "defaults to the :sucker_punch adapter" do
+      MultiWorker.default_adapter.should == :sucker_punch
+    end
+  end
+
+  context "when using the :sucker_punch adapter" do
+    before(:each) do
+      TestWorker.any_instance.should_receive(:perform).once.with("foo")
+    end
+
+    it "::perform_async uses Sucker Punch" do
+      TestWorker.perform_async("foo")
+    end
+
+    it "MultiWorker.enqueue uses Sucker Punch" do
+      MultiWorker.enqueue(TestWorker, "foo")
+    end
+
+    it "::perform delegates to #perform" do
+      TestWorker.perform("foo")
+    end
+  end
+end

data/spec/adapters/threaded_in_memory_queue_spec.rb

@@ -0,0 +1,25 @@
+require 'threaded_in_memory_queue'
+ThreadedInMemoryQueue.inline = true
+
+require 'test_workers'
+
+describe TestWorker do
+  it_behaves_like "a worker"
+end
+
+describe MultiWorker do
+  context "when ThreadedInMemoryQueue is loaded" do
+    it "defaults to the :threaded_in_memory_queue adapter" do
+      MultiWorker.default_adapter.should == :threaded_in_memory_queue
+    end
+  end
+
+  context "when using the :threaded_in_memory_queue adapter" do
+    it "performs the work using ThreadedInMemoryQueue" do
+      expect(TestWorker).to receive(:perform).exactly(3).times.with("foo")
+      TestWorker.perform_async("foo")
+      MultiWorker.enqueue(TestWorker, "foo")
+      TestWorker.perform("foo")
+    end
+  end
+end

data/spec/adapters/torquebox_backgroundable_spec.rb

@@ -0,0 +1,31 @@
+exit unless jruby?
+
+require 'torquebox/messaging'
+require 'torquebox/messaging/backgroundable'
+require 'torquebox/core'
+#java_import 'org.torquebox.core.util.StringUtils'
+
+require 'test_workers'
+
+describe TestWorker do
+  it_behaves_like "a worker"
+
+  it { should be_a ::TorqueBox::Messaging::Backgroundable}
+end
+
+describe MultiWorker do
+  context "when TorqueBox::Messaging::Backgroundable is loaded" do
+    it "defaults to the :sidekiq adapter" do
+      MultiWorker.default_adapter.should == :torquebox_backgroundable
+    end
+  end
+
+  context "when using the :torquebox_backgroundable adapter" do
+    it "puts a message on the queue" do
+      #@queue.should_receive(:publish).exactly(2).times
+      TorqueBox::Messaging::Backgroundable::Util.should_receive(:publish_message).exactly(2).times
+      TestWorker.perform_async("foo")
+      MultiWorker.enqueue(TestWorker, "foo")
+    end
+  end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,59 @@
+describe MultiWorker do
+  context 'configuration' do
+    it 'yields itself in a configuration block' do
+      MultiWorker.configure do
+        self.should == MultiWorker
+      end
+    end
+
+    it 'allows the default adapter to be set' do
+      MultiWorker.configure do
+        default_adapter :foo
+      end
+
+      MultiWorker.default_adapter.should == :foo
+      
+      MultiWorker.instance_variable_set(:@default_adapter, nil)
+    end
+
+    it 'picks a default adapter automatically' do
+      MultiWorker.default_adapter.should_not be_nil
+    end
+
+    it 'provides default options' do
+      MultiWorker.default_options[:queue].should == :default
+      MultiWorker.default_options[:retry].should == false
+      MultiWorker.default_options[:lock].should == false
+      MultiWorker.default_options[:unique].should == false
+      MultiWorker.default_options[:status].should == false
+    end
+
+    it 'allows default options to be customized' do
+      MultiWorker.configure do
+        default_options :retry => true, :unique => true
+      end
+
+      MultiWorker.default_options[:retry].should == true
+      MultiWorker.default_options[:lock].should == false
+      MultiWorker.default_options[:unique].should == true
+      MultiWorker.default_options[:status].should == false
+
+      MultiWorker.instance_variable_set(:@default_options, nil)
+    end
+
+    it 'allows default options to be overriden on the worker' do
+      MultiWorker.configure do
+        default_adapter :foo
+      end
+
+      require 'multi_worker/adapters/inline'
+      MultiWorker::Adapters::Inline.should_receive(:configure) do |klass, opts|
+        opts[:queue].should == :background
+      end
+
+      custom_worker = Class.new do
+        worker :adapter => :inline, :queue => :background
+      end
+    end
+  end
+end