resque 0.2.0

data/Rakefile

@@ -0,0 +1,61 @@
+eval File.read('tasks/redis.rake')
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/lib'
+require 'resque/tasks'
+
+task :default => :test
+
+desc "Run tests"
+task :test do
+  # Don't use the rake/testtask because it loads a new
+  # Ruby interpreter - we want to run tests with the current
+  # `rake` so our library manager still works
+  Dir['test/*_test.rb'].each do |f|
+    require f
+  end
+end
+
+desc "Activate kicker - gem install kicker"
+task :kick do
+  exec "kicker -e rake lib test"
+end
+
+task :install => [ 'redis:install', 'dtach:install' ]
+
+desc "Build a gem"
+task :gem => [ :test, :gemspec, :build ]
+
+begin
+  require 'jeweler'
+  $LOAD_PATH.unshift 'lib'
+  require 'resque/version'
+
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "resque"
+    gemspec.summary = ""
+    gemspec.description = ""
+    gemspec.email = "chris@ozmm.org"
+    gemspec.homepage = "http://github.com/defunkt/resque"
+    gemspec.authors = ["Chris Wanstrath"]
+    gemspec.version = Resque::Version 
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: "
+  puts "gem install jeweler"
+end
+
+begin
+  require 'sdoc_helpers'
+rescue LoadError
+  puts "sdoc support not enabled. Please gem install sdoc-helpers."
+end
+
+desc "Push a new version to Gemcutter"
+task :publish => [ :test, :gemspec, :build ] do
+  system "git tag v#{Resque::Version}"
+  system "git push origin v#{Resque::Version}"
+  system "git push origin master"
+  system "gem push pkg/resque-#{Resque::Version}.gem"
+  system "git clean -fd"
+  exec "rake pages"
+end

data/TODO.md

@@ -0,0 +1,60 @@
+Little Stuff
+-----------
+
+[ ] Show stale workers in red with a warning icon in the Sinatra app
+
+
+Big Stuff
+---------
+
+### async
+
+I want the `async` helper to be first class. Something like this:
+
+    class Repository < ActiveRecord::Base
+        include Resque::AsyncHelper
+    end
+
+This adds an `async` instance method and a `perform` class method.
+
+The `async` method looks like this:
+
+    def async(method, *args)
+      Resque.enqueue(self.class, id, method, *args)
+    end
+
+The `perform` method looks like this:
+
+    def self.perform(id, method, *args)
+      find(id).send(method, *args)
+    end
+
+Of course, you can define your own `self.perform` and have it still 
+work beautifully. We might override ours in GitHub to look like this:
+
+    def self.perform(id, method, *args)
+      return unless repo = cached_by_id(id)
+      repo.send(method, *args)
+    end
+
+Then: `@repo.async(:update_disk_usage)` issues a job equivalent to:
+
+    Resque.enqueue(Repository, 44, :update_disk_usage)
+
+Booyah.
+
+
+### gem install
+
+`gem install resque` should pull in yajl, redis, sinatra, rake, and rack
+
+Do it like Unicorn does it.
+
+### Parent / Child => Master / Workers
+
+On an ideal setup (REE + Linux) you'll have 2N Resque processes
+running at any time: N parents and N children.
+
+We can cut this number down to N+1 by moving from a parent / child
+architecture to a master / workers architecture.
+

data/bin/resque

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'resque'
+
+def kill(worker)
+  abort "** resque kill WORKER_ID" if worker.nil?
+  pid = worker.split(':')[1].to_i
+
+  begin
+    Process.kill("KILL", pid)
+    puts "** killed #{worker}"
+  rescue Errno::ESRCH
+    puts "** worker #{worker} not running"
+  end
+
+  remove worker
+end
+
+def remove(worker)
+  abort "** resque remove WORKER_ID" if worker.nil?
+
+  Resque.remove_worker(worker)
+  puts "** removed #{worker}"
+end
+
+def list
+  if Resque.workers.any?
+    Resque.workers.each do |worker|
+      puts "#{worker} (#{worker.state})"
+    end
+  else
+    puts "None"
+  end
+end
+
+if (i = ARGV.index('-r')) && ARGV[i+1]
+  Resque.redis = ARGV[i+1]
+  ARGV.delete_at(i)
+  ARGV.delete_at(i+1)
+end
+
+case ARGV[0]
+when 'kill'
+  kill ARGV[1]
+when 'remove'
+  remove ARGV[1]
+when 'list'
+  list
+else
+  puts "Usage: resque [-r redis_host:redis_port] COMMAND [option]"
+  puts
+  puts "Commands:"
+  puts "  remove WORKER   Removes a worker"
+  puts "  kill WORKER     Kills a worker"
+  puts "  list            Lists known workers"
+end

data/bin/resque-web

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+__DIR__ = File.expand_path(File.dirname(__FILE__))
+
+if `which rackup`.empty?
+  abort "** Can't find `rackup` in PATH."
+end
+
+if ARGV.include?('-h')
+  puts <<-usage
+Usage: resque-web [ruby options] [rack options] [resque config]
+
+Starts a Resque front-end by way of `rackup`.
+
+Ruby options:
+  -e, --eval LINE          evaluate a LINE of code
+  -d, --debug              set debugging flags (set $DEBUG to true)
+  -w, --warn               turn warnings on for your script
+  -I, --include PATH       specify $LOAD_PATH (may be used more than once)
+  -r, --require LIBRARY    require the library, before executing your script
+Rack options:
+  -s, --server SERVER      serve using SERVER (webrick/mongrel)
+  -o, --host HOST          listen on HOST (default: 0.0.0.0)
+  -p, --port PORT          use PORT (default: 9292)
+  -E, --env ENVIRONMENT    use ENVIRONMENT for defaults (default: development)
+  -D, --daemonize          run daemonized in the background
+  -P, --pid FILE           file to store PID (default: rack.pid)
+Common options:
+  -h, --help               Show this message
+      --version            Show version
+usage
+else
+  if !ENV['CONFIG']&&ARGV[-1]&&ARGV[-1][0]!=?-&&(ARGV[-2]?ARGV[-2][0]!=?-:true)
+    if File.file?(file = File.expand_path(ARGV[-1]))
+      ARGV.delete_at(-1)
+      ENV['CONFIG'] = file
+    else
+      abort "** Can't find #{file}"
+    end
+  end
+
+  args = ARGV
+  ENV['RUBYLIB'] = ENV['RUBYLIB'].to_s + ':' + __DIR__ + '/../lib'
+  args.unshift '-e', 'require "resque";load ENV["CONFIG"] if ENV["CONFIG"]'
+  args.push File.expand_path(File.dirname(__FILE__) + "/../config.ru")
+  exec "rackup", *args
+end

data/config.ru

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require 'logger'
+
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/lib')
+require 'resque/server'
+
+use Rack::ShowExceptions
+run Resque::Server.new

data/deps.rip

@@ -0,0 +1,5 @@
+git://github.com/ezmobius/redis-rb.git eed200ad
+git://github.com/brianmario/yajl-ruby.git 0.6.3
+git://github.com/sinatra/sinatra.git 0.9.4
+git://github.com/rack/rack.git 1.0
+rake

data/examples/async_helper.rb

@@ -0,0 +1,31 @@
+# If you want to just call a method on an object in the background,
+# we can easily add that functionality to Resque.
+#
+# This is similar to DelayedJob's `send_later`.
+#
+# Keep in mind that, unlike DelayedJob, only simple Ruby objects
+# can be persisted.
+#
+# If it can be represented in JSON, it can be stored in a job.
+
+# Here's our ActiveRecord class
+class Repository < ActiveRecord::Base
+  # This will be called by a worker when a job needs to be processed
+  def self.perform(id, method, *args)
+    find(id).send(method, *args)
+  end
+
+  # We can pass this any Repository instance method that we want to
+  # run later.
+  def async(method, *args)
+    Resque.enqueue(Repository, id, method, *args)
+  end
+end
+
+# Now we can call any method and have it execute later:
+
+@repo.async(:update_disk_usage)
+
+# or
+
+@repo.async(:update_network_source_id, 34)

data/examples/demo/README.markdown

@@ -0,0 +1,71 @@
+Resque Demo
+-----------
+
+This is a dirt simple Resque setup for you to play with.
+
+
+### Starting the Demo App
+
+Here's how to run the Sinatra app:
+
+    $ git clone git://github.com/defunkt/resque.git
+    $ cd resque/examples/demo
+    $ rackup config.ru
+    $ open http://localhost:9292/
+
+Click 'Create New Job' a few times. You should see the number of
+pending jobs rising.
+  
+
+### Starting the Demo Worker
+
+Now in another shell terminal start the worker:
+
+    $ cd resque/examples/demo
+    $ VERBOSE=true QUEUE=default rake resque:work
+
+You should see the following output:
+
+    *** Starting worker hostname:90185:default
+    *** got: (Job{default} | Demo::Job | [{}])
+    Processed a job!
+    *** done: (Job{default} | Demo::Job | [{}])
+
+You can also use `VVERBOSE` (very verbose) if you want to see more:
+
+    $ VERBOSE=true QUEUE=default rake resque:work
+    *** Starting worker hostname:90399:default
+    ** [05:55:09 2009-09-16] 90399: Registered signals
+    ** [05:55:09 2009-09-16] 90399: Checking default
+    ** [05:55:09 2009-09-16] 90399: Found job on default
+    ** [05:55:09 2009-09-16] 90399: got: (Job{default} | Demo::Job | [{}])
+    ** [05:55:09 2009-09-16] 90399: resque: Forked 90401 at 1253141709
+    ** [05:55:09 2009-09-16] 90401: resque: Processing default since 1253141709
+    Processed a job!
+    ** [05:55:10 2009-09-16] 90401: done: (Job{default} | Demo::Job | [{}])
+
+Notice that our workers `require 'job'` in our `Rakefile`. This
+ensures they have our app loaded and can access the job classes.
+
+
+### Starting the Resque frontend
+
+Great, now let's check out the Resque frontend. Either click on 'View
+Resque' in your web browser or run:
+
+    $ open http://localhost:9292/resque/
+    
+You should see the Resque web frontend. 404 page? Don't forget the
+trailing slash!
+
+
+### config.ru
+
+The `config.ru` shows you how to mount multiple Rack apps. Resque
+should work fine on a subpath - feel free to load it up in your
+Passenger app and protect it with some basic auth.
+
+
+### That's it!
+
+Click around, add some more queues, add more jobs, do whatever, have fun.

data/examples/demo/Rakefile

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+require 'resque/tasks'
+require 'job'

data/examples/demo/app.rb

@@ -0,0 +1,27 @@
+require 'sinatra'
+require 'resque'
+require 'job'
+
+module Demo
+  class App < Sinatra::Base
+    get '/' do
+      info = Resque.info
+      out = "<html><head><title>Resque Demo</title></head><body>"
+      out << "<p>"
+      out << "There are #{info[:pending]} pending and "
+      out << "#{info[:processed]} processed jobs across #{info[:queues]} queues."
+      out << "</p>"
+      out << '<form method="POST">'
+      out << '<input type="submit" value="Create New Job"/>'
+      out << '&nbsp;&nbsp;<a href="/resque/">View Resque</a>'
+      out << '</form>'
+      out << "</body></html>"
+      out
+    end
+
+    post '/' do
+      Resque.enqueue(Job, params)
+      redirect "/"
+    end
+  end
+end

data/examples/demo/config.ru

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+require 'logger'
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+require 'app'
+require 'resque/server'
+
+use Rack::ShowExceptions
+
+# Set the AUTH env variable to your basic auth password to protect Resque.
+AUTH_PASSWORD = ENV['AUTH']
+if AUTH_PASSWORD
+  Resque::Server.use Rack::Auth::Basic do |username, password|
+    password == AUTH_PASSWORD
+  end
+end
+
+run Rack::URLMap.new \
+  "/"       => Demo::App.new,
+  "/resque" => Resque::Server.new

data/examples/demo/job.rb

@@ -0,0 +1,12 @@
+require 'resque'
+
+module Demo
+  module Job
+    @queue = :default
+
+    def self.perform(params)
+      sleep 1
+      puts "Processed a job!"
+    end
+  end
+end

data/examples/existing_classes_as_jobs.rb

@@ -0,0 +1,3 @@
+# Let's say this is a class in your app, already
+
+# TODO: example

data/examples/instance.rb

@@ -0,0 +1,11 @@
+# DelayedJob wants you to create instances. No problem.
+
+class Archive < Struct.new(:repo_id, :branch)
+  def self.perform(*args)
+    new(*args).perform
+  end
+
+  def perform
+    # do work!
+  end
+end

data/examples/simple.rb

@@ -0,0 +1,30 @@
+# This is a simple Resque job.
+class Archive
+  @queue = :file_serve
+
+  def self.perform(repo_id, branch = 'master')
+    repo = Repository.find(repo_id)
+    repo.create_archive(branch)
+  end
+end
+
+# This is in our app code
+class Repository < Model
+  # ... stuff ...
+
+  def async_create_archive(branch)
+    Resque.enqueue(Archive, self.id, branch)
+  end
+
+  # ... more stuff ...
+end
+
+# Calling this code:
+repo = Repository.find(22)
+repo.async_create_archive('homebrew')
+
+# Will return immediately and create a Resque job which is later
+# processed.
+
+# Essentially, this code is run by the worker when processing:
+Archive.perform(22, 'homebrew')