autoscaler 0.2.1 → 0.3.0

data/CHANGELOG.md

@@ -1,9 +1,15 @@
 # Changelog
 
+## 0.3.0
+
+- Downscale method changed from busy-waiting workers to a separate monitor process
+- Minimum Sidekiq version raised to 2.7 to take advantage of Worker API
+- Internal refactoring
+- Autoscaler::StubScaler may be used for local testing
+
 ## 0.2.1
 
 - Separate background activity flags to avoid crosstalk between processes
-- Autoscaler::StubScaler may be used for local testing
 
 ## 0.2.0
 

data/README.md

@@ -19,6 +19,9 @@ This gem uses the [Herkou-Api](https://github.com/heroku/heroku.rb) gem, which r
 
 Install the middleware in your `Sidekiq.configure_` blocks
 
+    require 'autoscaler/sidekiq'
+    require 'autoscaler/heroku_scaler'
+
     Sidekiq.configure_client do |config|
       config.client_middleware do |chain|
         chain.add Autoscaler::Sidekiq::Client, 'default' => Autoscaler::HerokuScaler.new
@@ -33,17 +36,12 @@ Install the middleware in your `Sidekiq.configure_` blocks
 
 ## Limits and Challenges
 
-- HerokuScaler includes an attempt at current-worker cache that may be overcomplication, and doesn't work very well (see next)
-- Multiple threads often send scaling requests at once.  Heroku seems to handle this well.
-- Workers sleep-loop and are not actually returned to the pool; when a job or timeout happen, they can all release at once.
-- If you set job-timeouts on your tasks, they will likely trigger on the sleep-loop (see previous).
+- HerokuScaler includes an attempt at current-worker cache that may be overcomplication, and doesn't work very well on the server
+- Multiple scale-down loops may be started, particularly if there are multiple jobs queued when the servers comes up.  Heroku seems to handle multiple scale-down commands well.
+- The scale-down monitor is triggered on job completion (and server middleware is only run around jobs), so if the server nevers processes any jobs, it won't turn off.
 - The retry and schedule lists are considered - if you schedule a long-running task, the process will not scale-down.
 - If background jobs trigger jobs in other scaled processes, please note you'll need `config.client_middleware` in your `Sidekiq.configure_server` block in order to scale-up.
 
-### Long Jobs
-
-Since the shutdown check gets performed every time a job completes, the shutdown-timeout will need to be longer than the longest job.  For mixed workloads, you might want to have multiple sidekiq processes defined.  I use one with many workers for general work, and a single-worker process for long import jobs.  See `examples/complex.rb`
-
 ## Tests
 
 The project is setup to run RSpec with Guard.  It expects a redis instance on a custom port, which is started by the Guardfile.

data/lib/autoscaler/sidekiq.rb

@@ -1,114 +1,11 @@
-require 'sidekiq'
+require 'autoscaler/sidekiq/client'
+require 'autoscaler/sidekiq/monitor_middleware_adapter'
 
 module Autoscaler
   # namespace module for Sidekiq middlewares
   module Sidekiq
-    # Sidekiq client middleware
-    # Performs scale-up when items are queued and there are no workers running
-    class Client
-      # @param [Hash] scalers map of queue(String) => scaler (e.g. {HerokuScaler}).
-      #   Which scaler to use for each sidekiq queue
-      def initialize(scalers)
-        @scalers = scalers
-      end
-
-      # Sidekiq middleware api method
-      def call(worker_class, item, queue)
-        @scalers[queue] && @scalers[queue].workers = 1
-        yield
-      end
-    end
-
     # Sidekiq server middleware
     # Performs scale-down when the queue is empty
-    class Server
-      # @param [scaler] scaler object that actually performs scaling operations (e.g. {HerokuScaler})
-      # @param [Numeric] timeout number of seconds to wait before shutdown
-      # @param [Array[String]] specified_queues list of queues to monitor to determine if there is work left.  Defaults to all sidekiq queues.
-      def initialize(scaler, timeout, specified_queues = nil)
-        @scaler = scaler
-        @timeout = timeout
-        @specified_queues = specified_queues
-      end
-
-      # Sidekiq middleware api entry point
-      def call(worker, msg, queue)
-        working!(queue)
-        yield
-      ensure
-        working!(queue)
-        wait_for_task_or_scale
-      end
-
-      private
-      def refresh_sidekiq_queues!
-        @sidekiq_queues = ::Sidekiq::Stats.new.queues
-      end
-
-      attr_reader :sidekiq_queues
-
-      def queue_names
-        (@specified_queues || sidekiq_queues.keys)
-      end
-
-      def queued_work?
-        queue_names.any? {|name| sidekiq_queues[name].to_i > 0 }
-      end
-
-      def scheduled_work?
-        empty_sorted_set?("schedule")
-      end
-
-      def retry_work?
-        empty_sorted_set?("retry")
-      end
-
-      def empty_sorted_set?(sorted_set)
-        ss = ::Sidekiq::SortedSet.new(sorted_set)
-        ss.any? { |job| queue_names.include?(job.queue) }
-      end
-
-      def pending_work?
-        refresh_sidekiq_queues!
-        queued_work? || scheduled_work? || retry_work?
-      end
-
-      def wait_for_task_or_scale
-        loop do
-          return if pending_work?
-          return @scaler.workers = 0 if idle?
-          sleep(0.5)
-        end
-      end
-
-      def working!(queue)
-        active_at queue, Time.now
-      end
-
-      # test support
-      def idle!(queue)
-        active_at queue, Time.now - @timeout*2
-      end
-
-      def idle_time
-        t = last_activity
-        return 0 unless t
-        Time.now - Time.parse(t)
-      end
-
-      def idle?
-        idle_time > @timeout
-      end
-
-      def last_activity
-        ::Sidekiq.redis {|c|
-          queue_names.map {|q| c.get('background_activity:'+q)}.compact.max
-        }
-      end
-
-      def active_at(queue, time)
-        ::Sidekiq.redis {|c| c.set('background_activity:'+queue, time)}
-      end
-    end
+    Server = MonitorMiddlewareAdapter
   end
 end

data/lib/autoscaler/sidekiq/activity.rb

@@ -0,0 +1,51 @@
+require 'sidekiq'
+
+module Autoscaler
+  module Sidekiq
+    # Tracks activity timeouts using Sidekiq's redis connection
+    class Activity
+      # @param [Numeric] timeout number of seconds to wait before shutdown
+      def initialize(timeout)
+        @timeout = timeout
+      end
+
+      # Record that a queue has activity
+      # @param [String] queue
+      def working!(queue)
+        active_at queue, Time.now
+      end
+
+      # Record that a queue is idle and timed out - mostly for test support
+      # @param [String] queue
+      def idle!(queue)
+        active_at queue, Time.now - timeout*2
+      end
+
+      # Have the watched queues timed out?
+      # @param [Array[String]] queues list of queues to monitor to determine if there is work left
+      # @return [boolean]
+      def idle?(queues)
+        idle_time(queues) > timeout
+      end
+
+      private
+      attr_reader :timeout
+
+      def idle_time(queues)
+        t = last_activity(queues)
+        return 0 unless t
+        Time.now - Time.parse(t)
+      end
+
+      def last_activity(queues)
+        ::Sidekiq.redis {|c|
+          queues.map {|q| c.get('background_activity:'+q)}.compact.max
+        }
+      end
+
+      def active_at(queue, time)
+        ::Sidekiq.redis {|c| c.set('background_activity:'+queue, time)}
+      end
+    end
+  end
+end

data/lib/autoscaler/sidekiq/celluloid_monitor.rb

@@ -0,0 +1,75 @@
+require 'celluloid'
+
+module Autoscaler
+  module Sidekiq
+    # Actor to monitor the sidekiq server for scale-down
+    class CelluloidMonitor
+      include Celluloid
+
+      # @param [scaler] scaler object that actually performs scaling operations (e.g. {HerokuScaler})
+      # @param [Numeric] timeout number of seconds to wait before shutdown
+      # @param [System] system interface to the queuing system that provides `pending_work?`
+      def initialize(scaler, timeout, system)
+        @scaler = scaler
+        @timeout = timeout
+        @poll = [timeout/4.0, 0.5].max
+        @system = system
+        @running = false
+      end
+
+      # Mostly sleep until there has been no activity for the timeout
+      def wait_for_downscale
+        once do
+          active_now!
+
+          while active? || time_left?
+            sleep(@poll)
+            update_activity
+          end
+
+          @scaler.workers = 0
+        end
+      end
+
+      # Notify the monitor that a job is starting
+      def starting_job
+      end
+
+      # Notify the monitor that a job has finished
+      def finished_job
+        active_now!
+        async.wait_for_downscale
+      end
+
+      private
+      attr_reader :system
+
+      def active?
+        system.pending_work? || system.working?
+      end
+
+      def update_activity
+        active_now! if active?
+      end
+
+      def active_now!
+        @activity = Time.now
+      end
+
+      def time_left?
+        (Time.now - @activity) < @timeout
+      end
+
+      def once
+        return if @running
+
+        begin
+          @running = true
+          yield
+        ensure
+          @running = false
+        end
+      end
+    end
+  end
+end

data/lib/autoscaler/sidekiq/client.rb

@@ -0,0 +1,19 @@
+module Autoscaler
+  module Sidekiq
+    # Sidekiq client middleware
+    # Performs scale-up when items are queued and there are no workers running
+    class Client
+      # @param [Hash] scalers map of queue(String) => scaler (e.g. {HerokuScaler}).
+      #   Which scaler to use for each sidekiq queue
+      def initialize(scalers)
+        @scalers = scalers
+      end
+
+      # Sidekiq middleware api method
+      def call(worker_class, item, queue)
+        @scalers[queue] && @scalers[queue].workers = 1
+        yield
+      end
+    end
+  end
+end

data/lib/autoscaler/sidekiq/monitor_middleware_adapter.rb

@@ -0,0 +1,33 @@
+require 'autoscaler/sidekiq/queue_system'
+require 'autoscaler/sidekiq/celluloid_monitor'
+
+module Autoscaler
+  module Sidekiq
+    # Shim to the existing autoscaler interface
+    # Starts the monitor and notifies it of job events that may occur while it's sleeping
+    class MonitorMiddlewareAdapter
+      # @param [scaler] scaler object that actually performs scaling operations (e.g. {HerokuScaler})
+      # @param [Numeric] timeout number of seconds to wait before shutdown
+      # @param [Array[String]] specified_queues list of queues to monitor to determine if there is work left.  Defaults to all sidekiq queues.
+      def initialize(scaler, timeout, specified_queues = nil)
+        system = QueueSystem.new(specified_queues)
+        unless monitor
+          CelluloidMonitor.supervise_as(:autoscaler_monitor, scaler, timeout, system)
+        end
+      end
+
+      # Sidekiq middleware api entry point
+      def call(worker, msg, queue)
+        monitor.async.starting_job
+        yield
+      ensure
+        monitor.async.finished_job
+      end
+
+      private
+      def monitor
+        Celluloid::Actor[:autoscaler_monitor]
+      end
+    end
+  end
+end

data/lib/autoscaler/sidekiq/queue_system.rb

@@ -0,0 +1,72 @@
+require 'sidekiq/api'
+
+module Autoscaler
+  module Sidekiq
+    # Interface to to interrogate the queuing system
+    class QueueSystem
+      # @param [Array[String]] specified_queues list of queues to monitor to determine if there is work left.  Defaults to all sidekiq queues.
+      def initialize(specified_queues = nil)
+        @specified_queues = specified_queues
+      end
+
+      # @return [boolean] whether there is queued work - does not include work currently in progress
+      def pending_work?
+        refresh_sidekiq_queues!
+        queued_work? || scheduled_work? || retry_work?
+      end
+
+      # @return [boolean] whether there are workers actively running
+      def working?
+        workers > 0
+      end
+
+      # @return [Array[String]]
+      def queue_names
+        (@specified_queues || sidekiq_queues.keys)
+      end
+
+      private
+      def queued_work?
+        queue_names.any? {|name| sidekiq_queues[name].to_i > 0 }
+      end
+
+      def scheduled_work?
+        empty_sorted_set?("schedule")
+      end
+
+      def retry_work?
+        empty_sorted_set?("retry")
+      end
+
+      attr_reader :sidekiq_queues
+
+      def refresh_sidekiq_queues!
+        @sidekiq_queues = ::Sidekiq::Stats.new.queues
+      end
+
+      def empty_sorted_set?(sorted_set)
+        ss = ::Sidekiq::SortedSet.new(sorted_set)
+        ss.any? { |job| queue_names.include?(job.queue) }
+      end
+
+      def workers
+        if @specified_queues
+          specified_workers
+        else
+          total_workers
+        end
+      end
+
+      def total_workers
+        ::Sidekiq::Workers.new.size
+      end
+
+      def specified_workers
+        refresh_sidekiq_queues!
+        ::Sidekiq::Workers.new.count {|name, work|
+          queue_names.include?(work['queue'])
+        }
+      end
+    end
+  end
+end

data/lib/autoscaler/sidekiq/sleep_wait_server.rb

@@ -0,0 +1,52 @@
+require 'autoscaler/sidekiq/queue_system'
+require 'autoscaler/sidekiq/activity'
+
+module Autoscaler
+  module Sidekiq
+    # Sidekiq server middleware
+    # Performs scale-down when the queue is empty
+    class SleepWaitServer
+      # @param [scaler] scaler object that actually performs scaling operations (e.g. {HerokuScaler})
+      # @param [Numeric] timeout number of seconds to wait before shutdown
+      # @param [Array[String]] specified_queues list of queues to monitor to determine if there is work left.  Defaults to all sidekiq queues.
+      def initialize(scaler, timeout, specified_queues = nil)
+        @scaler = scaler
+        @activity = Activity.new(timeout)
+        @system = QueueSystem.new(specified_queues)
+      end
+
+      # Sidekiq middleware api entry point
+      def call(worker, msg, queue)
+        working!(queue)
+        yield
+      ensure
+        working!(queue)
+        wait_for_task_or_scale
+      end
+
+      private
+      def wait_for_task_or_scale
+        loop do
+          return if pending_work?
+          return @scaler.workers = 0 if idle?
+          sleep(0.5)
+        end
+      end
+
+      attr_reader :system
+      attr_reader :activity
+
+      def pending_work?
+        system.pending_work?
+      end
+
+      def working!(queue)
+        activity.working!(queue)
+      end
+
+      def idle?
+        activity.idle?(system.queue_names)
+      end
+    end
+  end
+end

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

@@ -1,4 +1,4 @@
 module Autoscaler
   # version number
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/spec/autoscaler/sidekiq/activity_spec.rb

@@ -0,0 +1,21 @@
+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
+end

data/spec/autoscaler/sidekiq/celluloid_monitor_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'autoscaler/sidekiq/celluloid_monitor'
+require 'timeout'
+
+class TestSystem
+  def initialize(pending)
+    @pending = pending
+  end
+
+  def working?; false; end
+  def pending_work?; @pending; end
+end
+
+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(false)
+    manager = cut.new(scaler, 0, system)
+    Timeout.timeout(1) { manager.wait_for_downscale }
+    scaler.workers.should == 0
+    manager.terminate
+  end
+
+  it "does not scale with pending work" do
+    system = TestSystem.new(true)
+    manager = cut.new(scaler, 0, system)
+    expect {Timeout.timeout(1) { manager.wait_for_downscale }}.to raise_error Timeout::Error
+    scaler.workers.should == 1
+    manager.terminate
+  end
+end

data/spec/autoscaler/sidekiq/client_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+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)}
+
+  it 'scales' do
+    client.call(Class, {}, 'queue') {}
+    scaler.workers.should == 1
+  end
+
+  it('yields') {client.call(Class, {}, 'queue') {:foo}.should == :foo}
+end

data/spec/autoscaler/sidekiq/monitor_middleware_adapter_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'autoscaler/sidekiq/monitor_middleware_adapter'
+
+describe Autoscaler::Sidekiq::MonitorMiddlewareAdapter do
+  before do
+    @redis = Sidekiq.redis = REDIS
+    Sidekiq.redis {|c| c.flushdb }
+  end
+
+  let(:cut) {Autoscaler::Sidekiq::MonitorMiddlewareAdapter}
+  let(:scaler) {TestScaler.new(1)}
+  let(:server) {cut.new(scaler, 0, ['queue'])}
+
+  it('yields') {server.call(Object.new, {}, 'queue') {:foo}.should == :foo}
+end

data/spec/autoscaler/sidekiq/queue_system_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'autoscaler/sidekiq/queue_system'
+
+describe Autoscaler::Sidekiq::QueueSystem do
+  let(:cut) {Autoscaler::Sidekiq::QueueSystem}
+
+  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(['queue'])}
+
+  it {subject.queue_names.should == ['queue']}
+  it {subject.working?.should be_false}
+
+  describe 'no pending work' do
+    it "with no work" do
+      subject.stub(:sidekiq_queues).and_return({'queue' => 0, 'another_queue' => 1})
+      subject.should_not be_pending_work
+    end
+
+    it "with scheduled work in another queue" do
+      with_scheduled_work_in('another_queue')
+      subject.should_not be_pending_work
+    end
+
+    it "with retry work in another queue" do
+      with_retry_work_in('another_queue')
+      subject.should_not be_pending_work
+    end
+  end
+
+  describe 'with pending work' do
+    it "with enqueued work" do
+      subject.stub(:sidekiq_queues).and_return({'queue' => 1})
+      subject.should be_pending_work
+    end
+
+    it "with schedule work" do
+      with_scheduled_work_in('queue')
+      subject.should be_pending_work
+    end
+
+    it "with retry work" do
+      with_retry_work_in('queue')
+      subject.should be_pending_work
+    end
+  end
+end

data/spec/autoscaler/sidekiq/sleep_wait_server_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'autoscaler/sidekiq/sleep_wait_server'
+
+describe Autoscaler::Sidekiq::SleepWaitServer do
+  before do
+    @redis = Sidekiq.redis = REDIS
+    Sidekiq.redis {|c| c.flushdb }
+  end
+
+  let(:cut) {Autoscaler::Sidekiq::SleepWaitServer}
+  let(:scaler) {TestScaler.new(1)}
+  let(:server) {cut.new(scaler, 0, ['queue'])}
+
+  def when_run
+    server.call(Object.new, {}, 'queue') {}
+  end
+
+  it "scales with no work" do
+    server.stub(:pending_work?).and_return(false)
+    when_run
+    scaler.workers.should == 0
+  end
+
+  it "does not scale with pending work" do
+    server.stub(:pending_work?).and_return(true)
+    when_run
+    scaler.workers.should == 1
+  end
+
+  it('yields') {server.call(Object.new, {}, 'queue') {:foo}.should == :foo}
+end

data/spec/spec_helper.rb

@@ -6,3 +6,11 @@ RSpec.configure do |config|
 
   config.filter_run_excluding :online => true unless ENV['HEROKU_APP']
 end
+
+class TestScaler
+  attr_accessor :workers
+
+  def initialize(n = 0)
+    self.workers = n
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: autoscaler
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,30 +10,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-14 00:00:00.000000000 Z
+date: 2013-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 2.6.1
-    - - <
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '2.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 2.6.1
-    - - <
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '2.7'
 - !ruby/object:Gem::Dependency
   name: heroku-api
   requirement: !ruby/object:Gem::Requirement
@@ -139,7 +133,14 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/autoscaler/heroku_scaler.rb
+- lib/autoscaler/sidekiq/activity.rb
+- lib/autoscaler/sidekiq/celluloid_monitor.rb
+- lib/autoscaler/sidekiq/client.rb
+- lib/autoscaler/sidekiq/monitor_middleware_adapter.rb
+- lib/autoscaler/sidekiq/queue_system.rb
+- lib/autoscaler/sidekiq/sleep_wait_server.rb
 - lib/autoscaler/sidekiq.rb
+- lib/autoscaler/stub_scaler.rb
 - lib/autoscaler/version.rb
 - lib/autoscaler.rb
 - README.md
@@ -148,9 +149,14 @@ files:
 - examples/simple.rb
 - Guardfile
 - spec/autoscaler/heroku_scaler_spec.rb
-- spec/autoscaler/sidekiq_spec.rb
-- spec/spec_helper.rb
+- spec/autoscaler/sidekiq/activity_spec.rb
+- spec/autoscaler/sidekiq/celluloid_monitor_spec.rb
+- spec/autoscaler/sidekiq/client_spec.rb
+- spec/autoscaler/sidekiq/monitor_middleware_adapter_spec.rb
+- spec/autoscaler/sidekiq/queue_system_spec.rb
+- spec/autoscaler/sidekiq/sleep_wait_server_spec.rb
 - spec/redis_test.conf
+- spec/spec_helper.rb
 homepage: ''
 licenses: []
 post_install_message: 
@@ -178,7 +184,12 @@ summary: Start/stop Sidekiq workers on Heroku
 test_files:
 - Guardfile
 - spec/autoscaler/heroku_scaler_spec.rb
-- spec/autoscaler/sidekiq_spec.rb
-- spec/spec_helper.rb
+- spec/autoscaler/sidekiq/activity_spec.rb
+- spec/autoscaler/sidekiq/celluloid_monitor_spec.rb
+- spec/autoscaler/sidekiq/client_spec.rb
+- spec/autoscaler/sidekiq/monitor_middleware_adapter_spec.rb
+- spec/autoscaler/sidekiq/queue_system_spec.rb
+- spec/autoscaler/sidekiq/sleep_wait_server_spec.rb
 - spec/redis_test.conf
+- spec/spec_helper.rb
 has_rdoc: 

data/spec/autoscaler/sidekiq_spec.rb

@@ -1,137 +0,0 @@
-require 'spec_helper'
-require 'autoscaler/sidekiq'
-
-class Scaler
-  attr_accessor :workers
-
-  def initialize(n = 0)
-    self.workers = n
-  end
-end
-
-class Autoscaler::Sidekiq::Server
-  public :idle!
-  public :working!
-end
-
-describe Autoscaler::Sidekiq do
-  before do
-    @redis = Sidekiq.redis = REDIS
-    Sidekiq.redis {|c| c.flushdb }
-  end
-
-  let(:scaler) do
-    Scaler.new(workers)
-  end
-
-  describe Autoscaler::Sidekiq::Client do
-    let(:cut) {Autoscaler::Sidekiq::Client}
-    let(:client) {cut.new('queue' => scaler)}
-    let(:workers) {0}
-
-    describe 'scales' do
-      before {client.call(Class, {}, 'queue') {}}
-      it {scaler.workers.should == 1}
-    end
-
-    describe 'yields' do
-      it {client.call(Class, {}, 'queue') {:foo}.should == :foo}
-    end
-  end
-
-  describe Autoscaler::Sidekiq::Server do
-    let(:cut) {Autoscaler::Sidekiq::Server}
-    let(:server) {cut.new(scaler, 0, ['queue'])}
-    let(:workers) {1}
-
-    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
-
-    def when_run
-      server.call(Object.new, {}, 'queue') {}
-    end
-
-    def self.when_run_should_scale
-      it('should downscale') do
-        when_run
-        scaler.workers.should == 0
-      end
-    end
-
-    def self.when_run_should_not_scale
-      it('should not downscale') do
-        when_run
-        scaler.workers.should == 1
-      end
-    end
-
-    describe 'scales' do
-      context "with no work" do
-        before do
-          server.stub(:sidekiq_queues).and_return({'queue' => 0, 'another_queue' => 1})
-        end
-        when_run_should_scale
-      end
-
-      context "with scheduled work in another queue" do
-        before do
-          with_scheduled_work_in('another_queue')
-        end
-        when_run_should_scale
-      end
-
-      context "with retry work in another queue" do
-        before do
-          with_retry_work_in('another_queue')
-        end
-        when_run_should_scale
-      end
-
-      context "when another process is working" do
-        let(:other_process) {cut.new(Scaler.new(0), 10, ['other_queue'])}
-        before do
-          other_process.idle!('other_queue')
-          server.working!('queue')
-        end
-        it {other_process.should be_idle}
-      end
-    end
-
-    describe 'does not scale' do
-      context "with enqueued work" do
-        before do
-          server.stub(:sidekiq_queues).and_return({'queue' => 1})
-        end
-        when_run_should_not_scale
-      end
-
-      context "with schedule work" do
-        before do
-          with_scheduled_work_in('queue')
-        end
-        when_run_should_not_scale
-      end
-
-      context "with retry work" do
-        before do
-          with_retry_work_in('queue')
-        end
-        when_run_should_not_scale
-      end
-    end
-
-    describe 'yields' do
-      it {server.call(Object.new, {}, 'queue') {:foo}.should == :foo}
-    end
-  end
-end