autoscale 0.9.1

data/lib/autoscaler/stub_scaler.rb

@@ -0,0 +1,25 @@
+require 'heroku-api'
+
+module Autoscaler
+  # A minimal scaler to use as stub for local testing
+  class StubScaler
+    # @param [String] type used to distinguish messages from multiple stubs
+    def initialize(type = 'worker')
+      @type = type
+      @workers = 0
+    end
+
+    attr_reader :type
+
+    # Read the current worker count
+    # @return [Numeric] number of workers
+    attr_reader :workers
+
+    # Set the number of workers
+    # @param [Numeric] n number of workers
+    def workers=(n)
+      p "Scaling #{type} to #{n}"
+      @workers = n
+    end
+  end
+end

data/lib/autoscaler/version.rb

@@ -0,0 +1,4 @@
+module Autoscaler
+  # version number
+  VERSION = "0.9.1"
+end

data/spec/autoscaler/binary_scaling_strategy_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'test_system'
+require 'autoscaler/binary_scaling_strategy'
+
+describe Autoscaler::BinaryScalingStrategy do
+  let(:cut) {Autoscaler::BinaryScalingStrategy}
+
+  it "scales with no work" do
+    system = TestSystem.new(0)
+    strategy = cut.new
+    strategy.call(system, 1).should == 0
+  end
+
+  it "does not scale with pending work" do
+    system = TestSystem.new(1)
+    strategy = cut.new(2)
+    strategy.call(system, 1).should == 2
+  end
+end

data/spec/autoscaler/counter_cache_memory_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'autoscaler/counter_cache_memory'
+
+describe Autoscaler::CounterCacheMemory do
+  let(:cut) {Autoscaler::CounterCacheMemory}
+
+  it {expect{cut.new.counter}.to raise_error(cut::Expired)}
+  it {cut.new.counter{1}.should == 1}
+
+  it 'set and store' do
+    cache = cut.new
+    cache.counter = 1
+    cache.counter.should == 1
+  end
+
+  it 'times out' do
+    cache = cut.new(0)
+    cache.counter = 1
+    expect{cache.counter.should}.to raise_error(cut::Expired)
+  end
+end

data/spec/autoscaler/counter_cache_redis_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'autoscaler/counter_cache_redis'
+
+describe Autoscaler::CounterCacheRedis do
+  before do
+    @redis = Sidekiq.redis = REDIS
+    Sidekiq.redis {|c| c.flushdb }
+  end
+
+  let(:cut) {Autoscaler::CounterCacheRedis}
+  subject {cut.new(Sidekiq.method(:redis))}
+
+  it {expect{subject.counter}.to raise_error(cut::Expired)}
+  it {subject.counter{1}.should == 1}
+
+  it 'set and store' do
+    subject.counter = 2
+    subject.counter.should == 2
+  end
+
+  it 'does not conflict with multiple worker types' do
+    other_worker_cache = cut.new(@redis, 300, 'other_worker')
+    subject.counter = 1
+    other_worker_cache.counter = 2
+
+    subject.counter.should == 1
+    other_worker_cache.counter = 2
+  end
+
+  it 'times out' do
+    cache = cut.new(Sidekiq.method(:redis), 1) # timeout 0 invalid
+    cache.counter = 3
+    sleep(2)
+    expect{cache.counter}.to raise_error(cut::Expired)
+  end
+
+  it 'passed a connection pool' do
+    cache = cut.new(@redis)
+    cache.counter = 4
+    cache.counter.should == 4
+  end
+
+  it 'passed a plain connection' do
+    connection = Redis.connect(:url => 'http://localhost:9736', :namespace => 'autoscaler')
+    cache = cut.new connection
+    cache.counter = 5
+    cache.counter.should == 5
+  end
+end

data/spec/autoscaler/delayed_shutdown_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'test_system'
+require 'autoscaler/delayed_shutdown'
+
+describe Autoscaler::DelayedShutdown do
+  let(:cut) {Autoscaler::DelayedShutdown}
+
+  it "returns normal values" do
+    strategy = cut.new(lambda{|s,t| 2}, 0)
+    strategy.call(nil, 1).should == 2
+  end
+
+  it "delays zeros" do
+    strategy = cut.new(lambda{|s,t| 0}, 60)
+    strategy.call(nil, 1).should == 1
+  end
+
+  it "eventually returns zero" do
+    strategy = cut.new(lambda{|s,t| 0}, 60)
+    strategy.stub(:level_idle_time).and_return(61)
+    strategy.call(nil, 61).should == 0
+  end
+end

data/spec/autoscaler/heroku_scaler_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'autoscaler/heroku_scaler'
+require 'heroku/api/errors'
+
+describe Autoscaler::HerokuScaler, :online => true do
+  let(:cut) {Autoscaler::HerokuScaler}
+  let(:client) {cut.new}
+  subject {client}
+
+  its(:workers) {should == 0}
+
+  describe 'scaled' do
+    around do |example|
+      client.workers = 1
+      example.yield
+      client.workers = 0
+    end
+
+    its(:workers) {should == 1}
+  end
+
+  shared_examples 'exception handler' do |exception_class|
+    before do
+      client.should_receive(:client){
+        raise exception_class.new(Exception.new('oops'))
+      }
+    end
+
+    describe "default handler" do
+      it {expect{client.workers}.to_not raise_error}
+      it {client.workers.should == 0}
+      it {expect{client.workers = 2}.to_not raise_error}
+    end
+
+    describe "custom handler" do
+      before do
+        @caught = false
+        client.exception_handler = lambda {|exception| @caught = true}
+      end
+
+      it {client.workers; @caught.should be_true}
+    end
+  end
+
+  describe 'exception handling', :focus => true do
+    it_behaves_like 'exception handler', Excon::Errors::SocketError
+    it_behaves_like 'exception handler', Heroku::API::Errors::Error
+  end
+end

data/spec/autoscaler/ignore_scheduled_and_retrying_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'test_system'
+require 'autoscaler/ignore_scheduled_and_retrying'
+
+describe Autoscaler::IgnoreScheduledAndRetrying do
+  let(:cut) {Autoscaler::IgnoreScheduledAndRetrying}
+
+  it "passes through enqueued" do
+    system = Struct.new(:enqueued).new(3)
+    strategy = proc {|system, time| system.enqueued}
+    cut.new(strategy).call(system, 0).should == 3
+  end
+
+  it "passes through workers" do
+    system = Struct.new(:workers).new(3)
+    strategy = proc {|system, time| system.workers}
+    cut.new(strategy).call(system, 0).should == 3
+  end
+
+  it "ignores scheduled" do
+    system = Struct.new(:scheduled).new(3)
+    strategy = proc {|system, time| system.scheduled}
+    cut.new(strategy).call(system, 0).should == 0
+  end
+
+  it "ignores retrying" do
+    system = Struct.new(:retrying).new(3)
+    strategy = proc {|system, time| system.retrying}
+    cut.new(strategy).call(system, 0).should == 0
+  end
+end
+
+

data/spec/autoscaler/linear_scaling_strategy_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+require 'test_system'
+require 'autoscaler/linear_scaling_strategy'
+
+describe Autoscaler::LinearScalingStrategy do
+  let(:cut) {Autoscaler::LinearScalingStrategy}
+
+  it "deactivates with no work" do
+    system = TestSystem.new(0)
+    strategy = cut.new(1)
+    strategy.call(system, 1).should == 0
+  end
+
+  it "activates with some work" do
+    system = TestSystem.new(1)
+    strategy = cut.new(1)
+    strategy.call(system, 1).should be > 0
+  end
+
+  it "minimally scales with minimal work" do
+    system = TestSystem.new(1)
+    strategy = cut.new(2, 2)
+    strategy.call(system, 1).should == 1
+  end
+
+  it "maximally scales with too much work" do
+    system = TestSystem.new(5)
+    strategy = cut.new(2, 2)
+    strategy.call(system, 1).should == 2
+  end
+
+  it "proportionally scales with some work" do
+    system = TestSystem.new(5)
+    strategy = cut.new(5, 2)
+    strategy.call(system, 1).should == 3
+  end
+
+  it "doesn't scale unless minimum is met" do
+    system = TestSystem.new(2)
+    strategy = cut.new(10, 4, 0.5)
+    strategy.call(system, 1).should == 0
+  end
+
+  it "scales proprotionally with a minimum" do
+    system = TestSystem.new(3)
+    strategy = cut.new(10, 4, 0.5)
+    strategy.call(system, 1).should == 1
+  end
+
+  it "scales maximally with a minimum" do
+    system = TestSystem.new(25)
+    strategy = cut.new(5, 4, 0.5)
+    strategy.call(system, 1).should == 5
+  end
+
+  it "scales proportionally with a minimum > 1" do
+    system = TestSystem.new(12)
+    strategy = cut.new(5, 4, 2)
+    strategy.call(system, 1).should == 2
+  end
+
+  it "scales maximally with a minimum factor > 1" do
+    system = TestSystem.new(30)
+    strategy = cut.new(5, 4, 2)
+    strategy.call(system, 1).should == 5
+  end
+
+  it "doesn't scale down engaged workers" do
+    system = TestSystem.new(0, 2)
+    strategy = cut.new(5, 4)
+    strategy.call(system, 1).should == 2
+  end
+
+  it "doesn't scale above max workers even if engaged workers is greater" do
+    system = TestSystem.new(40, 6)
+    strategy = cut.new(5, 4)
+    strategy.call(system, 1).should == 5
+  end
+
+  it "returns zero if requested capacity is zero" do
+    system = TestSystem.new(0, 0)
+    strategy = cut.new(0, 0)
+    strategy.call(system, 5).should == 0
+  end
+end

data/spec/autoscaler/sidekiq/activity_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'autoscaler/sidekiq/activity'
+
+describe Autoscaler::Sidekiq::Activity do
+  before do
+    @redis = Sidekiq.redis = REDIS
+    Sidekiq.redis {|c| c.flushdb }
+  end
+
+  let(:cut) {Autoscaler::Sidekiq::Activity}
+  let(:activity) {cut.new(0)}
+
+  context "when another process is working" do
+    let(:other_process) {cut.new(10)}
+    before do
+      activity.idle!('queue')
+      other_process.working!('other_queue')
+    end
+    it {activity.should be_idle(['queue'])}
+  end
+
+  it 'passed a connection pool' do
+    activity = cut.new(5, @redis)
+    activity.working!('queue')
+    activity.should_not be_idle(['queue'])
+  end
+
+  it 'passed a plain connection' do
+    connection = Redis.connect(:url => 'http://localhost:9736', :namespace => 'autoscaler')
+    activity = cut.new(5, connection)
+    activity.working!('queue')
+    activity.should_not be_idle(['queue'])
+  end
+end

data/spec/autoscaler/sidekiq/celluloid_monitor_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'test_system'
+require 'autoscaler/sidekiq/celluloid_monitor'
+require 'timeout'
+
+describe Autoscaler::Sidekiq::CelluloidMonitor do
+  before do
+    @redis = Sidekiq.redis = REDIS
+    Sidekiq.redis {|c| c.flushdb }
+  end
+
+  let(:cut) {Autoscaler::Sidekiq::CelluloidMonitor}
+  let(:scaler) {TestScaler.new(1)}
+
+  it "scales with no work" do
+    system = TestSystem.new(0)
+    manager = cut.new(scaler, lambda{|s,t| 0}, system)
+    Timeout.timeout(1) { manager.wait_for_downscale(0.5) }
+    scaler.workers.should == 0
+    manager.terminate
+  end
+
+  it "does not scale with pending work" do
+    system = TestSystem.new(1)
+    manager = cut.new(scaler, lambda{|s,t| 1}, system)
+    expect {Timeout.timeout(1) { manager.wait_for_downscale(0.5) }}.to raise_error Timeout::Error
+    scaler.workers.should == 1
+    manager.terminate
+  end
+
+  it "will downscale with initial workers zero" do
+    system = TestSystem.new(0)
+    scaler = TestScaler.new(0)
+    manager = cut.new(scaler, lambda{|s,t| 0}, system)
+    Timeout.timeout(1) { manager.wait_for_downscale(0.5) }
+    scaler.workers.should == 0
+    manager.terminate
+  end
+end

data/spec/autoscaler/sidekiq/client_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'test_system'
+require 'autoscaler/sidekiq/client'
+
+describe Autoscaler::Sidekiq::Client do
+  let(:cut) {Autoscaler::Sidekiq::Client}
+  let(:scaler) {TestScaler.new(0)}
+  let(:client) {cut.new('queue' => scaler)}
+
+  describe 'call' do
+    it 'scales' do
+      client.call(Class, {}, 'queue') {}
+      scaler.workers.should == 1
+    end
+
+    it 'scales with a redis pool' do
+      client.call(Class, {}, 'queue', ::Sidekiq.method(:redis)) {}
+      scaler.workers.should == 1
+    end
+
+    it('yields') {client.call(Class, {}, 'queue') {:foo}.should == :foo}
+  end
+
+  describe 'initial workers' do
+    it 'works with default arguments' do
+      client.set_initial_workers
+      scaler.workers.should == 0
+    end
+
+    it 'scales when necessary' do
+      client.set_initial_workers {|q| TestSystem.new(1)}
+      scaler.workers.should == 1
+    end
+  end
+end

data/spec/autoscaler/sidekiq/entire_queue_system_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'autoscaler/sidekiq/entire_queue_system'
+
+describe Autoscaler::Sidekiq::EntireQueueSystem do
+  let(:cut) {Autoscaler::Sidekiq::EntireQueueSystem}
+
+  before do
+    @redis = Sidekiq.redis = REDIS
+    Sidekiq.redis {|c| c.flushdb }
+  end
+
+  def with_work_in_set(queue, set)
+    payload = Sidekiq.dump_json('queue' => queue)
+    Sidekiq.redis { |c| c.zadd(set, (Time.now.to_f + 30.to_f).to_s, payload)}
+  end
+
+  def with_scheduled_work_in(queue)
+    with_work_in_set(queue, 'schedule')
+  end
+
+  def with_retry_work_in(queue)
+    with_work_in_set(queue, 'retry')
+  end
+
+  subject {cut.new}
+
+  it {subject.queue_names.should == []}
+  it {subject.workers.should == 0}
+
+  describe 'no queued work' do
+    it "with no work" do
+      subject.stub(:sidekiq_queues).and_return({'queue' => 0, 'another_queue' => 0})
+      subject.queued.should == 0
+    end
+
+    it "with no work and no queues" do
+      subject.queued.should == 0
+    end
+
+    it "with no scheduled work" do
+      subject.scheduled.should == 0
+    end
+
+    it "with no retry work" do
+      subject.retrying.should == 0
+    end
+  end
+
+  describe 'with queued work' do
+    it "with enqueued work" do
+      subject.stub(:sidekiq_queues).and_return({'queue' => 1})
+      subject.queued.should == 1
+    end
+
+    it "with schedule work" do
+      with_scheduled_work_in('queue')
+      subject.scheduled.should == 1
+    end
+
+    it "with retry work" do
+      with_retry_work_in('queue')
+      subject.retrying.should == 1
+    end
+  end
+end