resque-director 2.2.2 → 2.2.3

data/HISTORY.md

@@ -0,0 +1,41 @@
+## 2.2.2 (2011-09-09)
+
+* Bugfix: ignore wait_time when scaling to be within limits
+
+## 2.2.1 (2011-09-07)
+
+* Bugfix: make compatible with ruby 1.9
+
+## 2.2.0 (2011-09-07)
+
+* Added scaling workers working on multiple queues
+
+## 2.1.1 (2011-09-02)
+
+* Dont update last scaled time if start/stop block returns false
+
+## 2.1.0 (2011-09-01)
+
+* Change default log level to debug
+* Make gem compatible with resque ~> 1.10
+* add `no_enqueue_scale` option
+* scale within requirements before perform
+
+## 2.0.0 (2011-08-24)
+
+* Must extend the plugin instead of include
+* Modify resque's push/pop functionality to track time
+* Start/stop override lambdas accept queue-name as an argument
+
+## 1.1.0 (2011-08-23)
+
+* Added logging options
+* Bugfix: don't raise error when killing worker process
+
+## 1.0.1 (2011-08-20)
+
+* Bugfix: Dont append timestamp argument to resque job for non directed jobs
+
+## 1.0.0 (2011-08-20)
+
+* 1.0 release.

data/README.rdoc

@@ -4,7 +4,7 @@ Resque Director is a plugin for the Resque queueing system (http://github.com/de
 
 ==About
 
-resque-director is mainly useful for when you are managing a large number of workers and don't want to waste resources keeping all of them waiting when they are not being used. Also for jobs that are high priority or time sensitive you can have it autoscale workers when the time it took for the job to go through the queue is too long. For this reason resque director is useful in queues where the influx of jobs can change dramatically from time to time: enabling more workers during the times when the queue is filling up more quickly, and less in the opposite scenario. Different queues can be given different directions as well.
+Resque-director is useful for when you are managing a large number of workers and don't want to waste resources keeping all of them waiting when they are not being used. For jobs that are high priority or time sensitive you can have it autoscale workers based on how long it takes to go through the queue, or how big the queue becomes. In queues where the influx of jobs can change dramatically from time to time, resque director automatically scales more workers during the times when the queue is filling up more quickly, and less in the opposite scenario. Different queues can be given different directions as well.
 
 == Usage
 
@@ -27,7 +27,7 @@ For Example:
 
 <b>max_workers</b>:: specifies the maximum number of workers running at any point in time. It will never start more than the maximum number of workers. If anything less than or equal to zero is specified as the maximum it will be treated as if there is no maximum, and theoretically an infinite number of workers could be started. The default is 0.
 
-<b>max_time</b>:: the maximum time in seconds that a job takes to get pulled off the queue, if a job takes longer than this time then a worker is started. If anything less than or equal to zero is specified as the maximum time, this field will be ignored. The default is 0.
+<b>max_time</b>:: the maximum time in seconds that a job takes to go through the queue, if it takes longer than this time then a worker is started. If anything less than or equal to zero is specified as the maximum time, this field will be ignored. The default is 0.
 
 <b>max_queue</b>:: the maximum jobs that can build up in a queue, if more than this number of jobs build up then a worker is started. If anything less than or equal to zero is specified as the maximum queue, this field will be ignored. The default is 0.
 
@@ -35,7 +35,7 @@ For Example:
 
 === Conditions For Starting Workers
 
-A worker will be started if the queue length is greater than <b>max_queue</b> or if the time it takes a job to go through the queue is greater than <b>max_time</b>. Also a worker will only be started if the time since the last scaling is greater than <b>wait_time</b>. Workers will not be started if there are already the <b>max_workers</b> number of workers. By default resque-director allows you to have zero jobs running, when a job is enqueued then workers will be scaled within the max/min requirements you set. If there is not a single worker running, then the minimum number of workers will be scaled up (one worker will be scaled up if the minimum is zero).
+A worker will be started if the queue length is greater than <b>max_queue</b> or if the time it takes a job to go through the queue is greater than <b>max_time</b>. Also a worker will only be started if the time since the last scaling is greater than <b>wait_time</b>. Workers will not be started if there are already the <b>max_workers</b> number of workers. By default resque-director allows you to have zero workers running, when a job is enqueued then workers will be scaled within the max/min requirements you set. If there is not a single worker running, then the minimum number of workers will be scaled up (one worker will be scaled up if the minimum is zero).
 
 === Conditions For Removing Workers
 
@@ -52,7 +52,7 @@ The above options are plenty to handle the basic scaling of workers. The options
 
 === Start/Stop Options
 
-<b>start_override</b>:: You can set this option if you want to override the way to start a worker. This option takes a lambda closure that accepts the queue as an argument, the block you pass in will be responsible for starting a <em>SINGLE</em> worker allowing you to fully customize the starting of a worker. If your block returns false then that signifies that a worker was not started and the last scaled time will not be set. The default way a worker is started is with the system command: <tt>QUEUE=queue_name rake resque:work &</tt> where "queue_name" is the queue on which the job is running.
+<b>start_override</b>:: You can set this option if you want to override the way to start a worker. This option takes a lambda closure that accepts the queue as an argument, the block you pass in will be responsible for starting a <em>SINGLE</em> worker allowing you to fully customize the starting of a worker. If your block returns false then that signifies that a worker was not started and the last scaled time will not be set. The default way a worker is started is with the system command: "<tt>QUEUE=queue_name rake resque:work &</tt>" where "queue_name" is the queue on which the job is running.
 
 <b>stop_override</b>:: You can set this option if you want to override the way to stop a worker. This option takes a lambda closure that accepts the queue as an argument, the block you pass in will be responsible for stopping a <em>SINGLE</em> worker allowing you to fully customize the stopping of a worker. If your block returns false then that signifies that a worker was not stopped and the last scaled time will not be set. The default way a worker is stopped is that a QUIT signal is sent to a worker process. 
 

data/VERSION

@@ -1 +1 @@
-2.2.2
+2.2.3

data/lib/resque/plugins/director/scaler.rb

@@ -5,33 +5,30 @@ module Resque
         class << self
         
           def scale_up(number_of_workers=1)
-            number_of_workers = WorkerTracker.new.total_to_add(number_of_workers)
+            number_of_workers = WorkerTracker.total_to_add(number_of_workers)
             scaling(number_of_workers) do
               start(number_of_workers)
             end
           end
         
           def scale_down(number_of_workers=1)
-            tracker = WorkerTracker.new
-            number_of_workers = tracker.total_to_remove(number_of_workers)
+            number_of_workers = WorkerTracker.total_to_remove(number_of_workers)
             scaling(number_of_workers) do
-              stop(tracker, number_of_workers)
+              stop(number_of_workers)
             end
           end
           
           def scale_down_to_minimum
-            tracker = WorkerTracker.new
-            number_of_workers = tracker.total_to_go_to_minimum 
-            stop(tracker, number_of_workers)
+            number_of_workers = WorkerTracker.total_to_go_to_minimum
+            stop(number_of_workers)
           end
           
           def scale_within_requirements
-            tracker = WorkerTracker.new
-            number_of_workers = tracker.total_for_requirements
+            number_of_workers = WorkerTracker.total_for_requirements
             if number_of_workers > 0
               set_last_scaled unless start(number_of_workers) == false
             elsif number_of_workers < 0
-              set_last_scaled unless stop(tracker, number_of_workers * -1) == false
+              set_last_scaled unless stop(number_of_workers * -1) == false
             end
           end
           
@@ -59,10 +56,10 @@ module Resque
             start_default(number_of_workers)
           end
           
-          def stop(tracker, number_of_workers)
+          def stop(number_of_workers)
             Config.log("stopping #{number_of_workers} workers on queue:#{Config.queue}") if number_of_workers > 0
             return override(number_of_workers, Config.stop_override) if Config.stop_override
-            stop_default(tracker, number_of_workers)
+            stop_default(number_of_workers)
           end
           
           def override(number_of_workers, override_block)
@@ -73,8 +70,8 @@ module Resque
             number_of_workers.times { system("QUEUE=#{[Config.queue].flatten.join(",")} rake resque:work &") }
           end
 
-          def stop_default(tracker, number_of_workers)
-            worker_pids = tracker.valid_worker_pids[0...number_of_workers]
+          def stop_default(number_of_workers)
+            worker_pids = WorkerTracker.valid_worker_pids[0...number_of_workers]
             worker_pids.each do |pid| 
               Process.kill("QUIT", pid) rescue nil
             end

data/lib/resque/plugins/director/worker_tracker.rb

@@ -2,62 +2,58 @@ module Resque
   module Plugins
     module Director
       class WorkerTracker
-        attr_reader :workers
-        
-        def initialize
-          @workers = current_workers
-          @number_working = @workers.size
-        end
+        class << self
           
-        def total_for_requirements
-          start_number = workers_to_start
-          stop_number = workers_to_stop
-          return start_number if start_number > 0 
-          return stop_number if stop_number < 0 
-          0
-        end
+          def total_for_requirements
+            start_number = workers_to_start
+            stop_number = workers_to_stop
+            return start_number if start_number > 0 
+            return stop_number if stop_number < 0 
+            0
+          end
         
-        def total_to_go_to_minimum
-          to_minimum =  @number_working - Config.min_workers
-          to_minimum > 0 ? to_minimum : 0
-        end
+          def total_to_go_to_minimum
+            to_minimum =  current_workers.size - Config.min_workers
+            to_minimum > 0 ? to_minimum : 0
+          end
       
-        def total_to_add(number_to_start)
-          return number_to_start if Config.max_workers <= 0
-          scale_limit = Config.max_workers - @number_working
-          Config.log("WORKER MAX REACHED: wanted to start #{number_to_start} workers on queue:#{Config.queue}") if scale_limit <= 0
-          number_to_start > scale_limit ? scale_limit : number_to_start
-        end
+          def total_to_add(number_to_start)
+            return number_to_start if Config.max_workers <= 0
+            scale_limit = Config.max_workers - current_workers.size
+            Config.log("WORKER MAX REACHED: wanted to start #{number_to_start} workers on queue:#{Config.queue}") if scale_limit <= 0
+            number_to_start > scale_limit ? scale_limit : number_to_start
+          end
         
-        def total_to_remove(number_to_stop)
-          min_workers = Config.min_workers <= 0 ? 1 : Config.min_workers
-          scale_limit = @number_working - min_workers
-          if scale_limit <= 0 && Config.min_workers > 0
-            Config.log("WORKER MIN REACHED: wanted to stop #{number_to_stop} workers on queue:#{Config.queue}")
+          def total_to_remove(number_to_stop)
+            min_workers = Config.min_workers <= 0 ? 1 : Config.min_workers
+            scale_limit = current_workers.size - min_workers
+            if scale_limit <= 0 && Config.min_workers > 0
+              Config.log("WORKER MIN REACHED: wanted to stop #{number_to_stop} workers on queue:#{Config.queue}")
+            end
+            number_to_stop > scale_limit ? scale_limit : number_to_stop
           end
-          number_to_stop > scale_limit ? scale_limit : number_to_stop
-        end
         
-        def valid_worker_pids
-          valid_workers = @workers.select{|w| w.hostname == `hostname`.chomp}
-          valid_workers.map{|worker| worker.to_s.split(":")[1].to_i }
-        end
+          def valid_worker_pids
+            valid_workers = current_workers.select{|w| w.hostname == `hostname`.chomp}
+            valid_workers.map{|worker| worker.to_s.split(":")[1].to_i }
+          end
         
-        private
+          private
         
-        def workers_to_start
-          min_workers = Config.min_workers <= 0 ? 1 : Config.min_workers
-          min_workers - @number_working
-        end
+          def workers_to_start
+            min_workers = Config.min_workers <= 0 ? 1 : Config.min_workers
+            min_workers - current_workers.size
+          end
         
-        def workers_to_stop
-          return 0 if Config.max_workers <= 0
-          Config.max_workers - @number_working
-        end
+          def workers_to_stop
+            return 0 if Config.max_workers <= 0
+            Config.max_workers - current_workers.size
+          end
         
-        def current_workers
-          Resque.workers.select do |w|
-            w.queues.map(&:to_s) == [Config.queue].flatten.map(&:to_s) && !w.shutdown?
+          def current_workers
+            Resque.workers.select do |w|
+              w.queues.map(&:to_s) == [Config.queue].flatten.map(&:to_s) && !w.shutdown?
+            end
           end
         end
       end

data/resque-director.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{resque-director}
-  s.version = "2.2.2"
+  s.version = "2.2.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = [%q{Nolan Frausto}]
-  s.date = %q{2011-09-09}
+  s.date = %q{2011-10-13}
   s.description = %q{resque plugin for automatically scaling workers based on the amount of time it takes a job to go through the queue and/or the length of the queue }
   s.email = %q{nrfrausto@gmail.com}
   s.extra_rdoc_files = [
@@ -17,8 +17,8 @@ Gem::Specification.new do |s|
     "README.rdoc"
   ]
   s.files = [
-    ".document",
     "Gemfile",
+    "HISTORY.md",
     "LICENSE.txt",
     "README.rdoc",
     "Rakefile",
@@ -42,7 +42,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/frausto/resque-director}
   s.licenses = [%q{MIT}]
   s.require_paths = [%q{lib}]
-  s.rubygems_version = %q{1.8.8}
+  s.rubygems_version = %q{1.8.6}
   s.summary = %q{A resque plugin for automatically scaling workers}
 
   if s.respond_to? :specification_version then

data/spec/resque/plugins/director/scaler_spec.rb

@@ -94,13 +94,13 @@ describe Resque::Plugins::Director::Scaler do
     end
     
     it "should scale workers down to the minimum" do
-      Resque.should_receive(:workers).and_return [@worker, @worker, @worker]
+      Resque.should_receive(:workers).any_number_of_times.and_return [@worker, @worker, @worker]
       Process.should_receive(:kill).twice
       subject.scale_down_to_minimum
     end
     
     it "should not scale if the workers are already at the minimum" do
-      Resque.should_receive(:workers).and_return [@worker]
+      Resque.should_receive(:workers).any_number_of_times.and_return [@worker]
       Process.should_not_receive(:kill)
       subject.scale_down_to_minimum
     end
@@ -108,7 +108,7 @@ describe Resque::Plugins::Director::Scaler do
     it "forces scaling by ignoring wait_time" do
       Resque::Plugins::Director::Config.setup(:wait_time => 60, :min_workers => 2)
       subject.scaling {}
-      Resque.should_receive(:workers).and_return [@worker, @worker, @worker]
+      Resque.should_receive(:workers).any_number_of_times.and_return [@worker, @worker, @worker]
       Process.should_receive(:kill)
       subject.scale_down_to_minimum
     end
@@ -121,14 +121,14 @@ describe Resque::Plugins::Director::Scaler do
     end
     
     it "should scale down a single worker by default" do
-      Resque.should_receive(:workers).and_return [@worker, @worker]
+      Resque.should_receive(:workers).any_number_of_times.and_return [@worker, @worker]
       
       Process.should_receive(:kill).once
       subject.scale_down
     end
     
     it "should scale down multiple workers" do
-      Resque.should_receive(:workers).and_return [@worker, @worker, @worker]
+      Resque.should_receive(:workers).any_number_of_times.and_return [@worker, @worker, @worker]
       pid = @worker.to_s.split(":")[1].to_i
       Process.should_receive(:kill).with("QUIT", pid)
       subject.scale_down(2)
@@ -137,13 +137,13 @@ describe Resque::Plugins::Director::Scaler do
     it "should not scale down more than the minimum allowed workers" do
       Resque::Plugins::Director::Config.setup :min_workers => 1
       
-      Resque.should_receive(:workers).and_return [@worker, @worker]
+      Resque.should_receive(:workers).any_number_of_times.and_return [@worker, @worker]
       Process.should_receive(:kill).once
       subject.scale_down(2)
     end
     
     it "should not throw exceptions when process throws exception" do
-      Resque.should_receive(:workers).and_return [@worker, @worker]
+      Resque.should_receive(:workers).any_number_of_times.and_return [@worker, @worker]
       Process.should_receive(:kill).and_throw(:Exception)
       lambda { subject.scale_down }.should_not raise_error
     end
@@ -152,7 +152,7 @@ describe Resque::Plugins::Director::Scaler do
       worker2 = Resque::Worker.new(:not_test)
       @worker.stub(:to_s => "host:1:test") 
       worker2.stub(:to_s => "host:2:test")
-      Resque.should_receive(:workers).and_return [worker2, @worker, @worker, worker2]
+      Resque.should_receive(:workers).any_number_of_times.and_return [worker2, @worker, @worker, worker2]
       
       Process.should_not_receive(:kill).with("QUIT", 2)
       Process.should_receive(:kill).with("QUIT", 1)
@@ -168,51 +168,46 @@ describe Resque::Plugins::Director::Scaler do
     end
     
     it "should kill worker by sending the QUIT signal to the workers pid" do
-      Resque.should_receive(:workers).and_return [@worker]
-      tracker = Resque::Plugins::Director::WorkerTracker.new
+      Resque.should_receive(:workers).any_number_of_times.and_return [@worker]
       
       Process.should_receive(:kill).with("QUIT", @pid)
-      subject.send(:stop, tracker, 1)
+      subject.send(:stop, 1)
     end
     
     it "should use the stop block to stop a worker if set" do
       test_block = lambda {|queue| }
       Resque::Plugins::Director::Config.setup :stop_override => test_block, :min_workers => 0
       
-      Resque.should_receive(:workers).and_return [@worker]
-      tracker = Resque::Plugins::Director::WorkerTracker.new
+      Resque.should_receive(:workers).any_number_of_times.and_return [@worker]
       
       test_block.should_receive(:call).with("test")
       Process.should_not_receive(:kill)
-      subject.send(:stop, tracker, 1)
+      subject.send(:stop, 1)
     end
     
     it "does not stop workers already set to be shutdown" do
       @worker.should_receive(:shutdown?).and_return(true)
-      Resque.should_receive(:workers).and_return [@worker]
-      tracker = Resque::Plugins::Director::WorkerTracker.new
+      Resque.should_receive(:workers).any_number_of_times.and_return [@worker]
       
       Process.should_not_receive(:kill).with("QUIT", @pid)
-      subject.send(:stop, tracker, 1)
+      subject.send(:stop, 1)
     end
     
     it "does not kill worker processes on different machines" do
       @worker.stub!(:hostname => "different_machine")
-      Resque.should_receive(:workers).and_return [@worker]
-      tracker = Resque::Plugins::Director::WorkerTracker.new
+      Resque.should_receive(:workers).any_number_of_times.and_return [@worker]
       
       Process.should_not_receive(:kill).with("QUIT", @pid)
-      subject.send(:stop, tracker, 1)
+      subject.send(:stop, 1)
     end
     
     it "stops workers on the same host if possible" do
       worker2 = Resque::Worker.new(:test)
       worker2.stub!(:hostname => "different_machine")
-      Resque.should_receive(:workers).and_return [worker2, @worker]
-      tracker = Resque::Plugins::Director::WorkerTracker.new
+      Resque.should_receive(:workers).any_number_of_times.and_return [worker2, @worker]
       
       Process.should_receive(:kill).with("QUIT", @pid)
-      subject.send(:stop, tracker, 1)
+      subject.send(:stop, 1)
     end
     
     it "ignores hostname if using custom stop script" do
@@ -220,12 +215,11 @@ describe Resque::Plugins::Director::Scaler do
       Resque::Plugins::Director::Config.setup :stop_override => test_block, :min_workers => 0
       
       @worker.stub!(:hostname => "different_machine")
-      Resque.should_receive(:workers).and_return [@worker]
-      tracker = Resque::Plugins::Director::WorkerTracker.new
+      Resque.should_receive(:workers).any_number_of_times.and_return [@worker]
       
       test_block.should_receive(:call).with("test")
       Process.should_not_receive(:kill)
-      subject.send(:stop, tracker, 1)
+      subject.send(:stop, 1)
     end
   end
   
@@ -264,7 +258,7 @@ describe Resque::Plugins::Director::Scaler do
       Time.stub(:now => @now)
       Resque::Plugins::Director::Config.setup :max_workers => 1, :wait_time => 60
       workers = 2.times.map { Resque::Worker.new(:test) }
-      Resque.should_receive(:workers).and_return(workers)
+      Resque.should_receive(:workers).any_number_of_times.and_return(workers)
       subject.should_receive(:stop)
       
       subject.scale_within_requirements
@@ -293,16 +287,16 @@ describe Resque::Plugins::Director::Scaler do
     it "should scale down the max number of workers if more than max" do
       Resque::Plugins::Director::Config.setup :max_workers => 1
       workers = 2.times.map { Resque::Worker.new(:test) }
-      Resque.should_receive(:workers).and_return(workers)
+      Resque.should_receive(:workers).any_number_of_times.and_return(workers)
       
-      subject.should_receive(:stop).with(anything, 1)
+      subject.should_receive(:stop).with(1)
       subject.scale_within_requirements
     end
     
     it "should not scale down if max_workers is zero" do
       Resque::Plugins::Director::Config.setup :max_workers => 0
       workers = 1.times.map { Resque::Worker.new(:test) }
-      Resque.should_receive(:workers).and_return(workers)
+      Resque.should_receive(:workers).any_number_of_times.and_return(workers)
       
       subject.should_not_receive(:stop)
       subject.scale_within_requirements

data/spec/resque/plugins/director/worker_tracker_spec.rb

@@ -8,22 +8,50 @@ describe Resque::Plugins::Director::WorkerTracker do
     @worker = Resque::Worker.new(:test)
   end
   
-  describe "#workers" do
-    before do
-      Resque::Plugins::Director::Config.queue = "worker_test"
-    end
-    
+  describe "#current_workers" do
     it"should return the workers for the queue" do
+      Resque::Plugins::Director::Config.queue = "worker_test"
       Resque::Worker.new(:other).register_worker
       expected_worker = Resque::Worker.new(:worker_test)
       expected_worker.register_worker
       
-      subject.new.workers.should == [expected_worker]
+      subject.send(:current_workers).should == [expected_worker]
     end
     
     it "should not return workers working on multiple queues" do
       Resque::Worker.new(:worker_test, :other).register_worker
-      subject.new.workers.should be_empty
+      subject.send(:current_workers).should be_empty
+    end
+    
+    it "sets the workers from the queue" do
+      Resque.should_receive(:workers).and_return [@worker, @worker, @worker]
+      subject.send(:current_workers).should == [@worker, @worker, @worker]
+    end
+    
+    it "does not set workers from different queues" do
+      other_worker = Resque::Worker.new(:other)
+      Resque.should_receive(:workers).and_return [@worker, other_worker, @worker]
+      subject.send(:current_workers).should == [@worker, @worker]
+    end
+    
+    it "does not set workers that are scheduled for shutdow" do
+      shutdown_worker = Resque::Worker.new(:test)
+      shutdown_worker.shutdown
+      Resque.should_receive(:workers).and_return [shutdown_worker, @worker, @worker]
+      subject.send(:current_workers).should == [@worker, @worker]
+    end
+    
+    it "does not set workers that have the queue included with others" do
+      other_worker = Resque::Worker.new(:other, :test)
+      Resque.should_receive(:workers).and_return [@worker, other_worker, @worker]
+      subject.send(:current_workers).should == [@worker, @worker]
+    end
+    
+    it "finds workers working on multiple queues if specified" do
+      other_worker = Resque::Worker.new(:other, :test)
+      Resque::Plugins::Director::Config.queue = [:other,:test]
+      Resque.should_receive(:workers).and_return [@worker, other_worker]
+      subject.send(:current_workers).should == [other_worker]
     end
   end
   
@@ -31,41 +59,41 @@ describe Resque::Plugins::Director::WorkerTracker do
     it "should limit the workers to be removed to not go below minimum allowed workers" do
       Resque.should_receive(:workers).and_return [@worker, @worker]
       Resque::Plugins::Director::Config.setup :min_workers => 1
-      subject.new.total_to_remove(2).should == 1
+      subject.total_to_remove(2).should == 1
     end
   
     it "always keeps at least one worker" do
       Resque.should_receive(:workers).and_return [@worker, @worker, @worker]
       Resque::Plugins::Director::Config.setup :min_workers => 0
-      subject.new.total_to_remove(2).should == 2
+      subject.total_to_remove(2).should == 2
     end
     
     it "should return zero if there is only one worker working" do
       Resque.should_receive(:workers).and_return [@worker]
       Resque::Plugins::Director::Config.setup :min_workers => 0
-      subject.new.total_to_remove(1).should == 0
+      subject.total_to_remove(1).should == 0
     end
   end
 
 
   describe "#total_to_add" do
     before do
-      Resque.should_receive(:workers).and_return [@worker, @worker]
+      Resque.stub(:workers).and_return [@worker, @worker]
     end
     
     it "should limit the workers to be removed to not go below minimum allowed workers" do
       Resque::Plugins::Director::Config.setup :max_workers => 3
-      subject.new.total_to_add(2).should == 1
+      subject.total_to_add(2).should == 1
     end
   
     it "should allow the workers to be removed if it stays above the minimum" do
       Resque::Plugins::Director::Config.setup :max_workers => 4
-      subject.new.total_to_add(2).should == 2
+      subject.total_to_add(2).should == 2
     end
   
     it "should not limit workers added if max_workers is zero" do
       Resque::Plugins::Director::Config.setup :max_workers => 0
-      subject.new.total_to_add(200).should == 200
+      subject.total_to_add(200).should == 200
     end
   end
 
@@ -73,25 +101,25 @@ describe Resque::Plugins::Director::WorkerTracker do
     it "should return the number of workers needed to meet the minimum requirement" do
       Resque.should_receive(:workers).and_return [@worker, @worker]
       Resque::Plugins::Director::Config.setup :min_workers => 4
-      subject.new.total_for_requirements.should == 2
+      subject.total_for_requirements.should == 2
     end
     
     it "should return the number of workers needed to meet the maximum requirement" do
-      Resque.should_receive(:workers).and_return [@worker, @worker]
+      Resque.should_receive(:workers).any_number_of_times.and_return [@worker, @worker]
       Resque::Plugins::Director::Config.setup :max_workers => 1
-      subject.new.total_for_requirements.should == -1
+      subject.total_for_requirements.should == -1
     end
     
     it "should return 1 no workers are running and the minimum is zero" do
       Resque.should_receive(:workers).and_return []
       Resque::Plugins::Director::Config.setup :min_workers => 0
-      subject.new.total_for_requirements.should == 1
+      subject.total_for_requirements.should == 1
     end
     
     it "should return 0 if number of workers is within requirements" do
-      Resque.should_receive(:workers).and_return [@worker, @worker]
+      Resque.should_receive(:workers).any_number_of_times.and_return [@worker, @worker]
       Resque::Plugins::Director::Config.setup :min_workers => 1, :max_workers => 3
-      subject.new.total_for_requirements.should == 0
+      subject.total_for_requirements.should == 0
     end
   end
   
@@ -99,19 +127,19 @@ describe Resque::Plugins::Director::WorkerTracker do
     it "should return the number to scale down to go to the minimum" do
       Resque.should_receive(:workers).and_return [@worker, @worker, @worker]
       Resque::Plugins::Director::Config.setup :min_workers => 2
-      subject.new.total_to_go_to_minimum.should == 1
+      subject.total_to_go_to_minimum.should == 1
     end
     
     it "should return zero if already at the minimum" do
       Resque.should_receive(:workers).and_return [@worker, @worker, @worker]
       Resque::Plugins::Director::Config.setup :min_workers => 3
-      subject.new.total_to_go_to_minimum.should == 0
+      subject.total_to_go_to_minimum.should == 0
     end
     
     it "should return zero if below the minimum" do
       Resque.should_receive(:workers).and_return [@worker, @worker, @worker]
       Resque::Plugins::Director::Config.setup :min_workers => 4
-      subject.new.total_to_go_to_minimum.should == 0
+      subject.total_to_go_to_minimum.should == 0
     end
   end
   
@@ -121,42 +149,8 @@ describe Resque::Plugins::Director::WorkerTracker do
       worker2 = Resque::Worker.new(:test)
       pid = worker2.to_s.split(":")[1].to_i
       Resque.should_receive(:workers).and_return [@worker, worker2]
-      tracker = Resque::Plugins::Director::WorkerTracker.new
       
-      tracker.valid_worker_pids.should == [pid]
-    end
-  end
-  
-  describe "#initialize" do
-    it "sets the workers from the queue" do
-      Resque.should_receive(:workers).and_return [@worker, @worker, @worker]
-      subject.new.workers.should == [@worker, @worker, @worker]
-    end
-    
-    it "does not set workers from different queues" do
-      other_worker = Resque::Worker.new(:other)
-      Resque.should_receive(:workers).and_return [@worker, other_worker, @worker]
-      subject.new.workers.should == [@worker, @worker]
-    end
-    
-    it "does not set workers that are scheduled for shutdow" do
-      shutdown_worker = Resque::Worker.new(:test)
-      shutdown_worker.shutdown
-      Resque.should_receive(:workers).and_return [shutdown_worker, @worker, @worker]
-      subject.new.workers.should == [@worker, @worker]
-    end
-    
-    it "does not set workers that have the queue included with others" do
-      other_worker = Resque::Worker.new(:other, :test)
-      Resque.should_receive(:workers).and_return [@worker, other_worker, @worker]
-      subject.new.workers.should == [@worker, @worker]
-    end
-    
-    it "finds workers working on multiple queues if specified" do
-      other_worker = Resque::Worker.new(:other, :test)
-      Resque::Plugins::Director::Config.queue = [:other,:test]
-      Resque.should_receive(:workers).and_return [@worker, other_worker]
-      subject.new.workers.should == [other_worker]
+      subject.valid_worker_pids.should == [pid]
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: resque-director
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 1
   prerelease: 
   segments: 
   - 2
   - 2
-  - 2
-  version: 2.2.2
+  - 3
+  version: 2.2.3
 platform: ruby
 authors: 
 - Nolan Frausto
@@ -15,9 +15,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-09 00:00:00 Z
+date: 2011-10-13 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
+  type: :runtime
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -31,8 +32,8 @@ dependencies:
   version_requirements: *id001
   name: resque
   prerelease: false
-  type: :runtime
 - !ruby/object:Gem::Dependency 
+  type: :development
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -47,8 +48,8 @@ dependencies:
   version_requirements: *id002
   name: rspec
   prerelease: false
-  type: :development
 - !ruby/object:Gem::Dependency 
+  type: :development
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -63,8 +64,8 @@ dependencies:
   version_requirements: *id003
   name: bundler
   prerelease: false
-  type: :development
 - !ruby/object:Gem::Dependency 
+  type: :development
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -79,8 +80,8 @@ dependencies:
   version_requirements: *id004
   name: jeweler
   prerelease: false
-  type: :development
 - !ruby/object:Gem::Dependency 
+  type: :development
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -93,8 +94,8 @@ dependencies:
   version_requirements: *id005
   name: rcov
   prerelease: false
-  type: :development
 - !ruby/object:Gem::Dependency 
+  type: :development
   requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -109,8 +110,8 @@ dependencies:
   version_requirements: *id006
   name: yajl-ruby
   prerelease: false
-  type: :development
 - !ruby/object:Gem::Dependency 
+  type: :development
   requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -125,7 +126,6 @@ dependencies:
   version_requirements: *id007
   name: json
   prerelease: false
-  type: :development
 description: "resque plugin for automatically scaling workers based on the amount of time it takes a job to go through the queue and/or the length of the queue "
 email: nrfrausto@gmail.com
 executables: []
@@ -136,8 +136,8 @@ extra_rdoc_files:
 - LICENSE.txt
 - README.rdoc
 files: 
-- .document
 - Gemfile
+- HISTORY.md
 - LICENSE.txt
 - README.rdoc
 - Rakefile
@@ -186,7 +186,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.8
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: A resque plugin for automatically scaling workers

data/.document

@@ -1,5 +0,0 @@
-lib/**/*.rb
-bin/*
-- 
-features/**/*.feature
-LICENSE.txt