heroku_delayed_job_autoscale 0.0.2

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in heroku_delayed_job_autoscale.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,43 @@
+PATH
+  remote: .
+  specs:
+    heroku_delayed_job_autoscale (0.0.1)
+      delayed_job (>= 2.1)
+      heroku (>= 1)
+      rush (>= 0.6)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.0.3)
+    configuration (1.2.0)
+    daemons (1.1.0)
+    delayed_job (2.1.2)
+      activesupport (~> 3.0)
+      daemons
+    fattr (2.2.0)
+    heroku (1.16.2)
+      json_pure (>= 1.2.0, < 1.5.0)
+      launchy (~> 0.3.2)
+      rest-client (>= 1.4.0, < 1.7.0)
+    json_pure (1.4.6)
+    launchy (0.3.7)
+      configuration (>= 0.0.5)
+      rake (>= 0.8.1)
+    mime-types (1.16)
+    rake (0.8.7)
+    rest-client (1.6.1)
+      mime-types (>= 1.16)
+    rush (0.6.7)
+      session
+    session (3.1.0)
+      fattr
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  delayed_job (>= 2.1)
+  heroku (>= 1)
+  heroku_delayed_job_autoscale!
+  rush (>= 0.6)

data/README.md

@@ -0,0 +1,36 @@
+# Heroku Delayed Job Autoscale
+Simply put, this gem saves you money on Heroku by only running the workers when you need them.  
+When a new job is enqueued, this gem will fire up a new worker instance if none are running. When the job finishes, it'll shut it down.
+
+## Usage
+Create a delayed job worker and include HerokuDelayedJobAutoscale::Autoscale:
+
+    class OnImageUpload
+      include HerokuDelayedJobAutoscale::Autoscale
+
+      def initialize(media)
+        @media = media
+      end
+
+      def perform
+        @media.create_thumb
+      end
+    end
+
+Done
+
+## Requirements
+* Rush >= 0.6 - https://github.com/heroku/rush
+* Heroku client >= 1 - https://github.com/heroku/heroku
+* Delayed Job >= 2.1 - https://github.com/collectiveidea/delayed_job
+
+I haven't tested lower versions, but it might work.
+
+## Caution
+Autoscale uses two DJ hooks. #after and #enqueue, which it just passes onto two methods autoscale\_after and autoscale\_enqueue.
+If you need to use either of those hooks yourself in your DJ worker, make sure you pass on the job to the autoscale\_methods manually.
+
+## Other
+Work is based of [pedro's autoscaling branch][1], but adapted for Delayed Job 2.1 and rails 3.
+
+[1]: https://github.com/pedro/delayed_job/tree/autoscaling

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/heroku_delayed_job_autoscale.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "heroku_delayed_job_autoscale/version"
+
+Gem::Specification.new do |s|
+  s.name        = "heroku_delayed_job_autoscale"
+  s.version     = HerokuDelayedJobAutoscale::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Peter Haza"]
+  s.email       = ["peter.haza@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{A simple gem which enables automatic on/off for workers in heroku, saving you money.}
+  s.description = %q{The module within this gem simply listens for enqueues and finished jobs.
+    On enqueue it'll fire up a new worker instance if none are running,
+    on finish it'll shut down the worker if there are no more jobs.}
+
+  s.rubyforge_project = "heroku_delayed_job_autoscale"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_dependency 'heroku', '>= 1'
+  s.add_dependency 'rush', '>= 0.6'
+  s.add_dependency 'delayed_job', '>= 2.1'
+end

data/lib/heroku_delayed_job_autoscale.rb

@@ -0,0 +1,40 @@
+require 'heroku_delayed_job_autoscale/managers/local'
+require 'heroku_delayed_job_autoscale/managers/heroku'
+
+module HerokuDelayedJobAutoscale
+  module Autoscale
+    
+    @@autoscale_manager = HerokuDelayedJobAutoscale::Manager::Local
+    
+    def enqueue(job)
+      autoscale_enqueue(job)
+    end
+
+    def autoscale_enqueue(job)
+      Rails.logger.debug "enqueue"
+
+      if autoscale_client.qty.zero?
+        autoscale_client.scale_up
+      end
+    end
+
+    def perform
+      raise "Not implemented"
+    end
+    
+    def after(job)
+      autoscale_after(job)
+    end
+    
+    def autoscale_after(job)
+      # after is triggered before the job is removed, hence we see if this is the last job
+      autoscale_client.scale_down unless job.class.count - 1  > 0
+    end
+
+    protected
+    def autoscale_client
+      @autoscale_client ||= @@autoscale_manager.new
+    end
+
+  end
+end

data/lib/heroku_delayed_job_autoscale/managers/heroku.rb

@@ -0,0 +1,24 @@
+module HerokuDelayedJobAutoscale
+  module Manager
+    class Heroku
+      def initialize(options={})
+        username = options[:username] || ENV['HEROKU_USERNAME']
+        password = options[:password] || ENV['HEROKU_PASSWORD']
+        @app     = options[:app]      || ENV['HEROKU_APP']
+        @client = ::Heroku::Client.new(username, password)
+      end
+
+      def qty
+        @client.info(@app)[:workers].to_i
+      end
+
+      def scale_up
+        @client.set_workers(@app, 1)
+      end
+
+      def scale_down
+        @client.set_workers(@app, 0)
+      end
+    end
+  end
+end

data/lib/heroku_delayed_job_autoscale/managers/local.rb

@@ -0,0 +1,20 @@
+module HerokuDelayedJobAutoscale
+  module Manager
+    class Local
+      def initialize(options={})
+      end
+
+      def qty
+        Rush::Box.new.processes.filter(:cmdline => /rake jobs:work/).size
+      end
+
+      def scale_up
+        Rush::Box.new[Rails.root].bash "rake jobs:work", :background => true
+      end
+
+      def scale_down
+        $exit = true
+      end
+    end
+  end
+end

data/lib/heroku_delayed_job_autoscale/version.rb

@@ -0,0 +1,3 @@
+module HerokuDelayedJobAutoscale
+  VERSION = "0.0.2"
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification 
+name: heroku_delayed_job_autoscale
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Peter Haza
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-10 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: heroku
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        version: "1"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rush
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 6
+        version: "0.6"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: delayed_job
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 1
+        version: "2.1"
+  type: :runtime
+  version_requirements: *id003
+description: |-
+  The module within this gem simply listens for enqueues and finished jobs.
+      On enqueue it'll fire up a new worker instance if none are running,
+      on finish it'll shut down the worker if there are no more jobs.
+email: 
+- peter.haza@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- heroku_delayed_job_autoscale.gemspec
+- lib/heroku_delayed_job_autoscale.rb
+- lib/heroku_delayed_job_autoscale/managers/heroku.rb
+- lib/heroku_delayed_job_autoscale/managers/local.rb
+- lib/heroku_delayed_job_autoscale/version.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: heroku_delayed_job_autoscale
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A simple gem which enables automatic on/off for workers in heroku, saving you money.
+test_files: []
+