autoscale 0.9.3 → 0.11.0

data/spec/autoscaler/sidekiq/specified_queue_system_spec.rb

@@ -24,40 +24,40 @@ describe Autoscaler::Sidekiq::SpecifiedQueueSystem do
 
   subject {cut.new(['queue'])}
 
-  it {subject.queue_names.should == ['queue']}
-  it {subject.workers.should == 0}
+  it {expect(subject.queue_names).to eq ['queue']}
+  it {expect(subject.workers).to eq 0}
 
   describe 'no queued work' do
     it "with no work" do
-      subject.stub(:sidekiq_queues).and_return({'queue' => 0, 'another_queue' => 1})
-      subject.queued.should == 0
+      allow(subject).to receive(:sidekiq_queues).and_return({'queue' => 0, 'another_queue' => 1})
+      expect(subject.queued).to eq 0
     end
 
     it "with scheduled work in another queue" do
       with_scheduled_work_in('another_queue')
-      subject.scheduled.should == 0
+      expect(subject.scheduled).to eq 0
     end
 
     it "with retry work in another queue" do
       with_retry_work_in('another_queue')
-      subject.retrying.should == 0
+      expect(subject.retrying).to eq 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
+      allow(subject).to receive(:sidekiq_queues).and_return({'queue' => 1})
+      expect(subject.queued).to eq 1
     end
 
     it "with schedule work" do
       with_scheduled_work_in('queue')
-      subject.scheduled.should == 1
+      expect(subject.scheduled).to eq 1
     end
 
     it "with retry work" do
       with_retry_work_in('queue')
-      subject.retrying.should == 1
+      expect(subject.retrying).to eq 1
     end
   end
 end

data/spec/autoscaler/sidekiq/thread_server_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'autoscaler/sidekiq/thread_server'
+require 'timeout'
+
+describe Autoscaler::Sidekiq::ThreadServer do
+  before do
+    @redis = Sidekiq.redis = REDIS
+    Sidekiq.redis {|c| c.flushdb }
+  end
+
+  let(:cut) {Autoscaler::Sidekiq::ThreadServer}
+  let(:scaler) {TestScaler.new(1)}
+
+  describe "thread core" do
+    it "scales with no work" do
+      server = cut.new(scaler, lambda{|s,t| 0})
+      Timeout.timeout(1) { server.run(0.5) }
+      expect(scaler.workers).to eq 0
+      server.terminate
+    end
+
+    it "does not scale with pending work" do
+      server = cut.new(scaler, lambda{|s,t| 1})
+      expect {Timeout.timeout(1) { server.run(0.5) }}.to raise_error Timeout::Error
+      expect(scaler.workers).to eq 1
+      server.terminate
+    end
+
+    it "will downscale with initial workers zero" do
+      scaler = TestScaler.new(0)
+      server = cut.new(scaler, lambda{|s,t| 0})
+      Timeout.timeout(1) { server.run(0.5) }
+      expect(scaler.workers).to eq 0
+      server.terminate
+    end
+  end
+
+  describe "Middleware interface" do
+    let(:server) {cut.new(scaler, 0, ['queue'])}
+
+    it('yields') {expect(server.call(Object.new, {}, 'queue') {:foo}).to eq :foo}
+    it('yields with a redis pool') {expect(server.call(Object.new, {}, 'queue', Sidekiq.method(:redis)) {:foo}).to eq :foo}
+  end
+end

data/spec/spec_helper.rb

@@ -1,10 +1,12 @@
+require 'rspec/its'
 require 'sidekiq'
-REDIS = Sidekiq::RedisConnection.create(:url => 'http://localhost:9736', :namespace => 'autoscaler')
+REDIS = Sidekiq::RedisConnection.create(:url => 'redis://localhost:9736', :namespace => 'autoscaler')
 
 RSpec.configure do |config|
   config.mock_with :rspec
 
-  config.filter_run_excluding :online => true unless ENV['HEROKU_APP']
+  config.filter_run_excluding :api1 => true unless ENV['HEROKU_API_KEY']
+  config.filter_run_excluding :platform_api => true unless ENV['HEROKU_ACCESS_TOKEN']
 end
 
 class TestScaler

data/spec/test_system.rb

@@ -8,4 +8,10 @@ class TestSystem
   def queued; @pending; end
   def scheduled; 0; end
   def retrying; 0; end
+  def total_work
+    queued + scheduled + retrying + workers
+  end
+  def any_work?
+    queued > 0 || scheduled > 0 || retrying > 0 || workers > 0
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: autoscale
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.11.0
 platform: ruby
 authors:
 - Justin Love
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-13 00:00:00.000000000 Z
+date: 2015-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -17,14 +17,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: heroku-api
   requirement: !ruby/object:Gem::Requirement
@@ -39,6 +39,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: platform-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -57,16 +71,58 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-process
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '0'
 description: Currently provides a Sidekiq middleware that does 0/1 scaling of Heroku
   processes
 email:
@@ -85,37 +141,37 @@ files:
 - lib/autoscaler/counter_cache_memory.rb
 - lib/autoscaler/counter_cache_redis.rb
 - lib/autoscaler/delayed_shutdown.rb
+- lib/autoscaler/heroku_platform_scaler.rb
 - lib/autoscaler/heroku_scaler.rb
 - lib/autoscaler/ignore_scheduled_and_retrying.rb
 - lib/autoscaler/linear_scaling_strategy.rb
 - lib/autoscaler/sidekiq.rb
 - lib/autoscaler/sidekiq/activity.rb
-- lib/autoscaler/sidekiq/celluloid_monitor.rb
 - lib/autoscaler/sidekiq/client.rb
 - lib/autoscaler/sidekiq/entire_queue_system.rb
-- lib/autoscaler/sidekiq/monitor_middleware_adapter.rb
 - lib/autoscaler/sidekiq/queue_system.rb
 - lib/autoscaler/sidekiq/sleep_wait_server.rb
 - lib/autoscaler/sidekiq/specified_queue_system.rb
+- lib/autoscaler/sidekiq/thread_server.rb
 - lib/autoscaler/stub_scaler.rb
 - lib/autoscaler/version.rb
 - spec/autoscaler/binary_scaling_strategy_spec.rb
 - spec/autoscaler/counter_cache_memory_spec.rb
 - spec/autoscaler/counter_cache_redis_spec.rb
 - spec/autoscaler/delayed_shutdown_spec.rb
+- spec/autoscaler/heroku_platform_scaler_spec.rb
 - spec/autoscaler/heroku_scaler_spec.rb
 - spec/autoscaler/ignore_scheduled_and_retrying_spec.rb
 - spec/autoscaler/linear_scaling_strategy_spec.rb
 - spec/autoscaler/sidekiq/activity_spec.rb
-- spec/autoscaler/sidekiq/celluloid_monitor_spec.rb
 - spec/autoscaler/sidekiq/client_spec.rb
 - spec/autoscaler/sidekiq/entire_queue_system_spec.rb
-- spec/autoscaler/sidekiq/monitor_middleware_adapter_spec.rb
 - spec/autoscaler/sidekiq/sleep_wait_server_spec.rb
 - spec/autoscaler/sidekiq/specified_queue_system_spec.rb
+- spec/autoscaler/sidekiq/thread_server_spec.rb
 - spec/spec_helper.rb
 - spec/test_system.rb
-homepage: ''
+homepage: https://github.com/JustinLove/autoscaler
 licenses: []
 metadata: {}
 post_install_message: 
@@ -144,16 +200,16 @@ test_files:
 - spec/autoscaler/counter_cache_memory_spec.rb
 - spec/autoscaler/counter_cache_redis_spec.rb
 - spec/autoscaler/delayed_shutdown_spec.rb
+- spec/autoscaler/heroku_platform_scaler_spec.rb
 - spec/autoscaler/heroku_scaler_spec.rb
 - spec/autoscaler/ignore_scheduled_and_retrying_spec.rb
 - spec/autoscaler/linear_scaling_strategy_spec.rb
 - spec/autoscaler/sidekiq/activity_spec.rb
-- spec/autoscaler/sidekiq/celluloid_monitor_spec.rb
 - spec/autoscaler/sidekiq/client_spec.rb
 - spec/autoscaler/sidekiq/entire_queue_system_spec.rb
-- spec/autoscaler/sidekiq/monitor_middleware_adapter_spec.rb
 - spec/autoscaler/sidekiq/sleep_wait_server_spec.rb
 - spec/autoscaler/sidekiq/specified_queue_system_spec.rb
+- spec/autoscaler/sidekiq/thread_server_spec.rb
 - spec/spec_helper.rb
 - spec/test_system.rb
 has_rdoc: 

data/lib/autoscaler/sidekiq/celluloid_monitor.rb

@@ -1,68 +0,0 @@
-require 'celluloid'
-require 'celluloid/supervision/deprecate'
-
-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 [Strategy] strategy object that decides the target number of workers (e.g. {BinaryScalingStrategy})
-      # @param [System] system interface to the queuing system for use by the strategy
-      def initialize(scaler, strategy, system)
-        @scaler = scaler
-        @strategy = strategy
-        @system = system
-        @running = false
-      end
-
-      # Periodically update the desired number of workers
-      # @param [Numeric] interval polling interval, mostly for testing
-      def wait_for_downscale(interval = 15)
-        once do
-          active_now!
-
-          workers = :unknown
-
-          begin
-            sleep(interval)
-            target_workers = @strategy.call(@system, idle_time)
-            workers = @scaler.workers = target_workers unless workers == target_workers
-          end while 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
-
-      def active_now!
-        @activity = Time.now
-      end
-
-      def idle_time
-        Time.now - @activity
-      end
-
-      def once
-        return if @running
-
-        begin
-          @running = true
-          yield
-        ensure
-          @running = false
-        end
-      end
-    end
-  end
-end

data/lib/autoscaler/sidekiq/monitor_middleware_adapter.rb

@@ -1,46 +0,0 @@
-require 'autoscaler/sidekiq/queue_system'
-require 'autoscaler/sidekiq/celluloid_monitor'
-require 'autoscaler/binary_scaling_strategy'
-require 'autoscaler/delayed_shutdown'
-
-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 [Strategy,Numeric] timeout strategy object that determines target workers, or a timeout  in seconds to be passed to {DelayedShutdown}+{BinaryScalingStrategy}
-      # @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)
-        unless monitor
-          CelluloidMonitor.supervise_as(:autoscaler_monitor,
-                                        scaler,
-                                        strategy(timeout),
-                                        QueueSystem.new(specified_queues))
-        end
-      end
-
-      # Sidekiq middleware api entry point
-      def call(worker, msg, queue, _ = nil)
-        monitor.async.starting_job
-        yield
-      ensure
-        # monitor might have gone, e.g. if Sidekiq has received SIGTERM
-        monitor.async.finished_job if monitor
-      end
-
-      private
-      def monitor
-        Celluloid::Actor[:autoscaler_monitor]
-      end
-
-      def strategy(timeout)
-        if timeout.respond_to?(:call)
-          timeout
-        else
-          DelayedShutdown.new(BinaryScalingStrategy.new, timeout)
-        end
-      end
-    end
-  end
-end

data/spec/autoscaler/sidekiq/celluloid_monitor_spec.rb

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