dyno_scaler 0.1.0

data/spec/dyno_scaler/configuration_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+describe DynoScaler::Configuration do
+  subject(:config) { described_class.new }
+
+  it "defaults max_workers to 1" do
+    config.max_workers.should eq(1)
+  end
+
+  it "defaults min_workers to 0" do
+    config.min_workers.should eq(0)
+  end
+
+  it "defaults to not enabled" do
+    config.enabled.should be_false
+  end
+
+  it "defaults job_worker_ratio to { 1 => 1, 2 => 25, 3 => 50, 4 => 75, 5 => 100 }" do
+    config.job_worker_ratio.should eq({
+      1 => 1,
+      2 => 25,
+      3 => 50,
+      4 => 75,
+      5 => 100
+    })
+  end
+
+  it "defaults application to nil" do
+    config.application.should be_nil
+  end
+
+  context "when HEROKU_API_KEY environment variable is configured" do
+    before { ENV['HEROKU_API_KEY'] = 'some-api-key' }
+    after  { ENV['HEROKU_API_KEY'] = nil }
+
+    it "defaults to enabled" do
+      config.should be_enabled
+    end
+  end
+
+  context "when HEROKU_APP environment variable is configured" do
+    before { ENV['HEROKU_APP'] = 'my-app-on-heroku' }
+    after  { ENV['HEROKU_APP'] = nil }
+
+    it "defaults application to the value of HEROKU_APP" do
+      config.application.should eq(ENV['HEROKU_APP'])
+    end
+  end
+
+  describe "async" do
+    it "defaults to false" do
+      config.async.should be_false
+    end
+
+    context "when set to true" do
+      before { config.async = true }
+
+      it "configures a GirlFriday-callable" do
+        config.async.should respond_to(:call)
+      end
+    end
+
+    context "when configured with a block" do
+      before do
+        config.async { :ok }
+      end
+
+      it "configures the callable" do
+        config.async.call.should eq(:ok)
+      end
+    end
+  end
+end

data/spec/dyno_scaler/heroku_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe DynoScaler::Heroku do
+  let(:application) { 'my-application-on-heroku' }
+  subject(:heroku_client) { DynoScaler::Heroku.new application }
+
+  let(:heroku_api) { mock(::Heroku::API, :post_ps_scale => false) }
+
+  before do
+    ::Heroku::API.stub!(:new).and_return(heroku_api)
+  end
+
+  describe "scaling workers" do
+    let(:quantity) { 2 }
+
+    it "scales workers of the application to the given number of workers" do
+      heroku_api.should_receive(:post_ps_scale).with(application, 'worker', quantity)
+      heroku_client.scale_workers(quantity)
+    end
+  end
+end
+

data/spec/dyno_scaler/manager_spec.rb

@@ -0,0 +1,349 @@
+require "spec_helper"
+
+describe DynoScaler::Manager do
+  let(:config) { DynoScaler.configuration }
+
+  subject(:manager) { DynoScaler::Manager.new }
+
+  let(:heroku) { mock(DynoScaler::Heroku, scale_workers: false) }
+
+  let(:workers)      { 0 }
+  let(:pending_jobs) { 0 }
+  let(:running_jobs) { 0 }
+
+  let(:options) do
+    {
+      workers: workers,
+      pending: pending_jobs,
+      working: running_jobs
+    }
+  end
+
+  before do
+    DynoScaler.reset!
+    DynoScaler.configuration.logger = Logger.new(StringIO.new)
+
+    config.max_workers = 5
+    config.application = 'my-app'
+    config.enabled = true
+
+    DynoScaler::Heroku.stub!(:new).with(config.application).and_return(heroku)
+  end
+
+  shared_examples_for "disabled" do
+    before { config.enabled = false }
+
+    it "does nothing" do
+      heroku.should_not_receive(:scale_workers)
+      perform_action
+    end
+  end
+
+  describe "scale up" do
+    def perform_action
+      manager.scale_up(options)
+    end
+
+    context "when there are no workers running" do
+      context "and there is no pending jobs" do
+        it "does nothing" do
+          heroku.should_not_receive(:scale_workers)
+          perform_action
+        end
+      end
+
+      DynoScaler.configuration.job_worker_ratio.keys.each do |number_of_workers|
+        context "and there is enough pending jobs so as to scale #{number_of_workers} workers" do
+          let(:pending_jobs) { config.job_worker_ratio[number_of_workers] }
+
+          it "scales workers to #{number_of_workers}" do
+            heroku.should_receive(:scale_workers).with(number_of_workers)
+            perform_action
+          end
+
+          it_should_behave_like "disabled"
+        end
+      end
+    end
+
+    context "when there is one worker running" do
+      let(:workers) { 1 }
+
+      context "and there is no pending jobs" do
+        it "does nothing" do
+          heroku.should_not_receive(:scale_workers)
+          perform_action
+        end
+      end
+
+      context "and there is less pending jobs that would require another worker" do
+        let(:pending_jobs) { config.job_worker_ratio[2] - 1 }
+
+        it "does nothing" do
+          heroku.should_not_receive(:scale_workers)
+          perform_action
+        end
+      end
+
+      context "and there is enough pending jobs as to scale another worker" do
+        let(:pending_jobs) { config.job_worker_ratio[2] }
+
+        it "scales workers" do
+          heroku.should_receive(:scale_workers).with(2)
+          perform_action
+        end
+      end
+    end
+
+    context "when there are many workers running" do
+      let(:workers) { 4 }
+
+      context "and there is no pending jobs" do
+        it "does nothing" do
+          heroku.should_not_receive(:scale_workers)
+          perform_action
+        end
+      end
+
+      context "and there is less pending jobs that would require another worker" do
+        let(:pending_jobs) { config.job_worker_ratio[4] - 1 }
+
+        it "does nothing" do
+          heroku.should_not_receive(:scale_workers)
+          perform_action
+        end
+      end
+
+      context "and there is enough pending jobs as to scale another worker" do
+        let(:pending_jobs) { config.job_worker_ratio[5] }
+
+        it "scales workers" do
+          heroku.should_receive(:scale_workers).with(5)
+          perform_action
+        end
+      end
+
+      context "and it is the maximum number of workers running" do
+        before { config.max_workers = workers }
+
+        context "and there is enough pending jobs as to scale another worker" do
+          let(:pending_jobs) { config.job_worker_ratio[5] }
+
+          it "does nothing" do
+            heroku.should_not_receive(:scale_workers)
+            perform_action
+          end
+        end
+      end
+    end
+  end
+
+  describe "scale down" do
+    def perform_action
+      manager.scale_down(options)
+    end
+
+    context "when there are no workers running" do
+      it "does nothing" do
+        heroku.should_not_receive(:scale_workers)
+        perform_action
+      end
+    end
+
+    context "when there is one worker running" do
+      let(:workers) { 1 }
+
+      context "and there are no pending jobs" do
+        context "and no running jobs" do
+          it "scales down" do
+            heroku.should_receive(:scale_workers).with(config.min_workers)
+            perform_action
+          end
+
+          context "when min_workers is configured with a different value" do
+            before { config.min_workers = 1 }
+
+            it "does nothing" do
+              heroku.should_not_receive(:scale_workers)
+              perform_action
+            end
+          end
+        end
+
+        context "but there are many running jobs" do
+          let(:running_jobs) { 4 }
+
+          it "does nothing" do
+            heroku.should_not_receive(:scale_workers)
+            perform_action
+          end
+        end
+      end
+
+      context "and there are pending jobs" do
+        let(:pending_jobs) { 1 }
+
+        context "and no running jobs" do
+          it "does nothing" do
+            heroku.should_not_receive(:scale_workers)
+            perform_action
+          end
+        end
+
+        context "but there are running jobs" do
+          let(:running_jobs) { 1 }
+
+          it "does nothing" do
+            heroku.should_not_receive(:scale_workers)
+            perform_action
+          end
+        end
+      end
+    end
+
+    context "when there are many workers running" do
+      let(:workers) { 4 }
+
+      context "and there are no pending jobs" do
+        context "and no running jobs" do
+          it "scales down" do
+            heroku.should_receive(:scale_workers).with(config.min_workers)
+            perform_action
+          end
+
+          context "when min_workers is configured with a different value" do
+            before { config.min_workers = 2 }
+
+            it "scales down to the min workers value" do
+              heroku.should_receive(:scale_workers).with(config.min_workers)
+              perform_action
+            end
+          end
+        end
+
+        context "but there are many running jobs" do
+          let(:running_jobs) { 4 }
+
+          it "does nothing" do
+            heroku.should_not_receive(:scale_workers)
+            perform_action
+          end
+        end
+      end
+
+      context "and there are pending jobs" do
+        let(:pending_jobs) { 1 }
+
+        context "and no running jobs" do
+          it "does nothing" do
+            heroku.should_not_receive(:scale_workers)
+            perform_action
+          end
+        end
+
+        context "but there are running jobs" do
+          let(:running_jobs) { 1 }
+
+          it "does nothing" do
+            heroku.should_not_receive(:scale_workers)
+            perform_action
+          end
+        end
+      end
+    end
+  end
+
+  describe "scale with options" do
+    let(:action) { :scale_up }
+    let(:options) do
+      {
+        action: action,
+        workers: workers,
+        pending: pending_jobs,
+        working: running_jobs
+      }
+    end
+
+    def perform_action
+      manager.scale_with(options)
+    end
+
+    context "when action is scale up" do
+      it "scales up passing options" do
+        manager.should_receive(:scale_up).with(options)
+        perform_action
+      end
+    end
+
+    context "when action is scale down" do
+      let(:action) { :scale_down }
+
+      it "scales down passing options" do
+        manager.should_receive(:scale_down).with(options)
+        perform_action
+      end
+    end
+
+    context "when no action is provided" do
+      let(:options) do
+        {
+          workers: workers,
+          pending: pending_jobs,
+          working: running_jobs
+        }
+      end
+
+      context "when there are no workers running" do
+        context "and there is no pending jobs" do
+          it "does nothing" do
+            manager.should_not_receive(:scale_up)
+            manager.should_not_receive(:scale_down)
+            perform_action
+          end
+        end
+
+        context "and there is pending jobs" do
+          let(:pending_jobs) { 2 }
+
+          it "scales up" do
+            manager.should_receive(:scale_up).with(options)
+            perform_action
+          end
+        end
+      end
+
+      context "when there are workers running" do
+        let(:workers) { 4 }
+
+        context "and there are no pending jobs" do
+          context "and no running jobs" do
+            it "scales down" do
+              manager.should_receive(:scale_down).with(options)
+              perform_action
+            end
+          end
+
+          context "but there are many running jobs" do
+            let(:running_jobs) { 4 }
+
+            it "does nothing" do
+              manager.should_not_receive(:scale_up)
+              manager.should_not_receive(:scale_down)
+              perform_action
+            end
+          end
+        end
+
+        context "and there are pending jobs" do
+          let(:pending_jobs) { 1 }
+
+          it "does nothing" do
+            manager.should_not_receive(:scale_up)
+            manager.should_not_receive(:scale_down)
+            perform_action
+          end
+        end
+      end
+    end
+  end
+end

data/spec/dyno_scaler/workers/resque_spec.rb

@@ -0,0 +1,201 @@
+require "spec_helper"
+
+require 'resque'
+
+class SampleJob
+  include DynoScaler::Workers::Resque
+
+  @queue = :sample
+
+  def self.perform
+    # do something
+  end
+
+  def self.reset!
+    @manager = nil
+  end
+end
+
+describe DynoScaler::Workers::Resque do
+  let(:manager) { mock(DynoScaler::Manager, scale_up: false, scale_down: false) }
+
+  let(:workers) { 0 }
+  let(:working) { 0 }
+  let(:pending) { 1 }
+
+  before do
+    Resque.stub!(:info).and_return({
+      workers: workers,
+      working: working,
+      pending: pending
+    })
+
+    SampleJob.reset!
+    DynoScaler::Manager.stub!(:new).and_return(manager)
+  end
+
+  def work_off(queue)
+    job = Resque::Job.reserve(queue)
+    job ? job.perform : fail("No jobs for queue '#{queue}'.")
+  end
+
+  describe "when enqueued" do
+    it "scales up" do
+      manager.should_receive(:scale_up).with(Resque.info)
+      Resque.enqueue(SampleJob)
+    end
+
+    context "when there are workers" do
+      let(:workers) { 2 }
+
+      it "passes the number of current workers to the manager" do
+        manager.should_receive(:scale_up).with(Resque.info)
+        Resque.enqueue(SampleJob)
+      end
+    end
+
+    context "when there are pending jobs" do
+      let(:pending) { 5 }
+
+      it "passes the number of pending jobs" do
+        manager.should_receive(:scale_up).with(Resque.info)
+        Resque.enqueue(SampleJob)
+      end
+    end
+
+    context "when scaling up is disabled" do
+      before { SampleJob.disable_scaling_up }
+      after  { SampleJob.enable_scaling_up  }
+
+      it "does not scale up" do
+        manager.should_not_receive(:scale_up)
+        Resque.enqueue(SampleJob)
+      end
+    end
+
+    context "when an error occurs while scaling up" do
+      before do
+        manager.stub!(:scale_up).and_raise("error")
+      end
+
+      it "does not raises it" do
+        capture(:stderr) do
+          expect { Resque.enqueue(SampleJob) }.to_not raise_error
+        end
+      end
+
+      it "enqueues the job" do
+        capture(:stderr) do
+          Resque.enqueue(SampleJob)
+          work_off(:sample)
+        end
+      end
+
+      it "prints a message in $stderr" do
+        capture(:stderr) { Resque.enqueue(SampleJob) }.should eq("Could not scale up workers: error\n")
+      end
+    end
+
+    context "and async is configured" do
+      let(:config) { DynoScaler.configuration }
+
+      context "with default processor" do
+        before { config.async = true }
+
+        it "calls the given async processor passing the current Resque info and the scale up action" do
+          config.async.should_receive(:call).with(Resque.info.merge(action: :scale_up))
+          Resque.enqueue(SampleJob)
+        end
+
+        context "and the Girl-Friday job is run" do
+          before { GirlFriday::Queue.immediate! }
+
+          after do
+            GirlFriday::Queue.queue!
+            DynoScaler.reset!
+          end
+
+          it "runs the scale up with the Resque info and the scale up action" do
+            DynoScaler.manager.should_receive(:scale_with).with(Resque.info.merge(action: :scale_up))
+            Resque.enqueue(SampleJob)
+          end
+        end
+      end
+
+      context "with a block" do
+        before do
+          config.async { |options| :ok }
+        end
+
+        it "calls the given async processor passing the current Resque info and the scale up action" do
+          config.async.should_receive(:call).with(Resque.info.merge(action: :scale_up))
+          Resque.enqueue(SampleJob)
+        end
+      end
+    end
+  end
+
+  describe "after performing" do
+    before do
+      Resque.enqueue(SampleJob)
+    end
+
+    it "scales down" do
+      manager.should_receive(:scale_down).with(Resque.info)
+      work_off(:sample)
+    end
+
+    context "when there are workers" do
+      let(:workers) { 2 }
+
+      it "passes the number of current workers to the manager" do
+        manager.should_receive(:scale_down).with(Resque.info)
+        work_off(:sample)
+      end
+    end
+
+    context "when there are pending jobs" do
+      let(:pending) { 5 }
+
+      it "passes the number of pending jobs" do
+        manager.should_receive(:scale_down).with(Resque.info)
+        work_off(:sample)
+      end
+    end
+
+    context "when there are running jobs" do
+      let(:working) { 5 }
+
+      it "passes the number of running jobs minus 1, since we do not count ourselves" do
+        manager.should_receive(:scale_down).with(Resque.info.merge(working: Resque.info[:working] - 1))
+        work_off(:sample)
+      end
+    end
+
+    context "when scaling down is disabled" do
+      before { SampleJob.disable_scaling_down }
+      after  { SampleJob.enable_scaling_down  }
+
+      it "does not scale down" do
+        manager.should_not_receive(:scale_down)
+        work_off(:sample)
+      end
+    end
+
+    context "when an error occurs while scaling down" do
+      before do
+        manager.stub!(:scale_down).and_raise("error")
+      end
+
+      it "does not raises it" do
+        capture(:stderr) do
+          expect { work_off(:sample) }.to_not raise_error
+        end
+      end
+
+      it "prints a message in $stderr" do
+        capture(:stderr) { work_off(:sample) }.should eq("Could not scale down workers: error\n")
+      end
+    end
+  end
+end

data/spec/dyno_scaler_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe DynoScaler do
+  it "returns a new configuration" do
+    DynoScaler.configuration.should be_a(DynoScaler::Configuration)
+  end
+
+  it "returns a new manager" do
+    DynoScaler.manager.should be_a(DynoScaler::Manager)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter 'spec'
+end
+
+require 'bundler/setup'
+
+ENV['RACK_ENV'] ||= 'test'
+
+Bundler.require :default, ENV['RACK_ENV']
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  # config.order = 'random'
+
+  config.before do
+    DynoScaler.configuration.logger = Logger.new(StringIO.new)
+  end
+
+  def capture(stream)
+    begin
+      stream = stream.to_s
+      eval "$#{stream} = StringIO.new"
+      yield
+      result = eval("$#{stream}").string
+    ensure
+      eval("$#{stream} = #{stream.upcase}")
+    end
+
+    result
+  end
+end