opengotham_resque 1.8.2

data/Rakefile

@@ -0,0 +1,112 @@
+#
+# Setup
+#
+
+load 'tasks/redis.rake'
+require 'rake/testtask'
+
+$LOAD_PATH.unshift 'lib'
+require 'resque/tasks'
+
+def command?(command)
+  system("type #{command} > /dev/null")
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "opengotham_resque"
+    gemspec.summary = "resque is a Redis-backed queueing system."
+    gemspec.email = "mjording@opengotham.com"
+    gemspec.homepage = "http://github.com/opengotham/resque"
+    gemspec.authors = ["Matthew Jording"]
+    gemspec.version = '1.8.2'
+    gemspec.add_dependency 'redis', ">= 2.0.0.rc2"
+    gemspec.add_dependency "opengotham_redis-namespace", ">= 0.4.4"
+    gemspec.add_dependency "vegas", ">= 0.1.2"
+    gemspec.add_dependency "sinatra", ">= 0.9.2"
+    gemspec.description = <<description
+    Resque is a Redis-backed Ruby library for creating background jobs,
+    placing those jobs on multiple queues, and processing them later.
+
+    Background jobs can be any Ruby class or module that responds to
+    perform. Your existing classes can easily be converted to background
+    jobs or you can create new classes specifically to do work. Or, you
+    can do both.
+
+    Resque is heavily inspired by DelayedJob (which rocks) and is
+    comprised of three parts:
+
+    * A Ruby library for creating, querying, and processing jobs
+    * A Rake task for starting a worker which processes jobs
+    * A Sinatra app for monitoring queues, jobs, and workers.
+description
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  warn "Jeweler not available. Install it with:"
+  warn "gem install jeweler"
+end
+#
+# Tests
+#
+
+task :default => :test
+
+desc "Run the test suite"
+task :test do
+  rg = command?(:rg)
+  Dir['test/**/*_test.rb'].each do |f|
+    rg ? sh("rg #{f}") : ruby(f)
+  end
+end
+
+if command? :kicker
+  desc "Launch Kicker (like autotest)"
+  task :kicker do
+    puts "Kicking... (ctrl+c to cancel)"
+    exec "kicker -e rake test lib examples"
+  end
+end
+
+
+#
+# Gem
+#
+
+task :install => [ 'redis:install', 'dtach:install' ]
+
+# begin
+#   require 'mg'
+#   MG.new("resque.gemspec")
+# rescue LoadError
+#   warn "mg not available."
+#   warn "Install it with: gem i mg"
+# end
+
+
+#
+# Documentation
+#
+# 
+# begin
+#   require 'sdoc_helpers'
+# rescue LoadError
+#   puts "sdoc support not enabled. Please gem install sdoc-helpers."
+# end
+
+
+#
+# Publishing
+#
+# 
+# desc "Push a new version to Gemcutter"
+# task :publish => "gem:publish" do
+#   require 'resque/version'
+# 
+#   sh "git tag v#{Resque::Version}"
+#   sh "git push origin v#{Resque::Version}"
+#   sh "git push origin master"
+#   sh "git clean -fd"
+#   exec "rake pages"
+# end

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,23 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+begin
+  require 'vegas'
+rescue LoadError
+  require 'rubygems'
+  require 'vegas'
+end  
+require 'resque/server'
+
+
+Vegas::Runner.new(Resque::Server, 'resque-web', {
+  :before_run => lambda {|v|
+    path = (ENV['RESQUECONFIG'] || v.args.first)
+    load path.to_s.strip if path
+  }
+}) do |runner, opts, app|
+  opts.on('-N NAMESPACE', "--namespace NAMESPACE", "set the Redis namespace") {|namespace|
+    runner.logger.info "Using Redis namespace '#{namespace}'"
+    Resque.redis.namespace = namespace
+  }
+end

data/config.ru

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require 'logger'
+
+$LOAD_PATH.unshift ::File.expand_path(::File.dirname(__FILE__) + '/lib')
+require 'resque/server'
+
+# Set the RESQUECONFIG env variable if you've a `resque.rb` or similar
+# config file you want loaded on boot.
+if ENV['RESQUECONFIG'] && ::File.exists?(::File.expand_path(ENV['RESQUECONFIG']))
+  load ::File.expand_path(ENV['RESQUECONFIG'])
+end
+
+use Rack::ShowExceptions
+run Resque::Server.new

data/deps.rip

@@ -0,0 +1,7 @@
+git://github.com/ezmobius/redis-rb.git 2.0.0.rc2
+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
+git://github.com/quirkey/vegas.git v0.1.2
+git://github.com/brynary/rack-test.git v0.5.3
+rake

data/docs/HOOKS.md

@@ -0,0 +1,121 @@
+Resque Hooks
+============
+
+You can customize Resque or write plugins using its hook API. In many
+cases you can use a hook rather than mess with Resque's internals.
+
+For a list of available plugins see
+<http://wiki.github.com/defunkt/resque/plugins>.
+
+
+Worker Hooks
+------------
+
+If you wish to have a Proc called before the worker forks for the
+first time, you can add it in the initializer like so:
+
+    Resque.before_first_fork do
+      puts "Call me once before the worker forks the first time"
+    end
+
+You can also run a hook before _every_ fork:
+
+    Resque.before_fork do |job|
+      puts "Call me before the worker forks"
+    end
+
+The `before_fork` hook will be run in the **parent** process. So, be
+careful - any changes you make will be permanent for the lifespan of
+the worker.
+
+And after forking:
+
+    Resque.after_fork do |job|
+      puts "Call me after the worker forks"
+    end
+
+The `after_fork` hook will be run in the child process and is passed
+the current job. Any changes you make, therefor, will only live as
+long as the job currently being processes.
+
+All worker hooks can also be set using a setter, e.g.
+
+    Resque.after_fork = proc { puts "called" }
+
+
+Job Hooks
+---------
+
+Plugins can utilize job hooks to provide additional behavior. A job
+hook is a method name in the following format:
+
+    HOOKNAME_IDENTIFIER
+
+For example, a `before_perform` hook which adds locking may be defined
+like this:
+
+    def before_perform_with_lock(*args)
+      set_lock!
+    end
+
+Once this hook is made available to your job (either by way of
+inheritence or `extend`), it will be run before the job's `perform`
+method is called. Hooks of each type are executed in alphabetical order,
+so `before_perform_a` will always be executed before `before_perform_b`.
+An unnamed hook (`before_perform`) will be executed first.
+
+The available hooks are:
+
+* `before_perform`: Called with the job args before perform. If it raises
+  `Resque::Job::DontPerform`, the job is aborted. If other exceptions
+  are raised, they will be propagated up the the `Resque::Failure`
+  backend.
+
+* `after_perform`: Called with the job args after it performs. Uncaught
+  exceptions will propagate up to the `Resque::Failure` backend.
+
+* `around_perform`: Called with the job args. It is expected to yield in order
+  to perform the job (but is not required to do so). It may handle exceptions
+  thrown by `perform`, but any that are not caught will propagate up to the
+  `Resque::Failure` backend.
+
+* `on_failure`: Called with the exception and job args if any exception occurs
+  while performing the job (or hooks).
+
+Hooks are easily implemented with superclasses or modules. A superclass could
+look something like this.
+
+    class LoggedJob
+      def self.before_perform_log_job(*args)
+        Logger.info "About to perform #{self} with #{args.inspect}"
+      end
+    end
+
+    class MyJob < LoggedJob
+      def self.perform(*args)
+        ...
+      end
+    end
+
+Modules are even better because jobs can use many of them.
+
+    module LoggedJob
+      def before_perform_log_job(*args)
+        Logger.info "About to perform #{self} with #{args.inspect}"
+      end
+    end
+
+    module RetriedJob
+      def on_failure_retry(e, *args)
+        Logger.info "Performing #{self} caused an exception (#{e}). Retrying..."
+        Resque.enqueue self, *args
+      end
+    end
+
+    class MyJob
+      extend LoggedJob
+      extend RetriedJob
+      def self.perform(*args)
+        ...
+      end
+    end

data/docs/PLUGINS.md

@@ -0,0 +1,93 @@
+Resque Plugins
+==============
+
+Resque encourages plugin development. For a list of available plugins,
+please see <http://wiki.github.com/defunkt/resque/plugins>.
+
+The `docs/HOOKS.md` file included with Resque documents the available
+hooks you can use to add or change Resque functionality. This document
+describes best practice for plugins themselves.
+
+
+Version
+-------
+
+Plugins should declare the major.minor version of Resque they are
+known to work with explicitly in their README.
+
+For example, if your plugin depends on features in Resque 2.1, please
+list "Depends on Resque 2.1" very prominently near the beginning of
+your README.
+
+Because Resque uses [Semantic Versioning][sv], you can safely make the
+following assumptions:
+
+* Your plugin will work with 2.2, 2.3, etc - no methods will be
+  removed or changed, only added.
+* Your plugin might not work with 3.0+, as APIs may change or be
+  removed.
+
+
+Namespace
+---------
+
+All plugins should live under the `Resque::Plugins` module to avoid
+clashing with first class Resque constants or other Ruby libraries.
+
+Good:
+
+* Resque::Plugins::Lock
+* Resque::Plugins::FastRetry
+
+Bad:
+
+* Resque::Lock
+* ResqueQueue
+
+
+Gem Name
+--------
+
+Gem names should be in the format of `resque-FEATURE`, where `FEATURE`
+succinctly describes the feature your plugin adds to Resque.
+
+Good:
+
+* resque-status
+* resque-scheduler
+
+Bad:
+
+* multi-queue
+* defunkt-resque-lock
+
+
+Hooks
+-----
+
+Job hook names should be namespaced to work properly.
+
+Good:
+
+* before_perform_lock
+* around_perform_check_status
+
+Bad:
+
+* before_perform
+* on_failure
+
+
+Lint
+----
+
+Plugins should test compliance to this document using the
+`Resque::Plugin.lint` method.
+
+For example:
+
+    assert_nothing_raised do
+      Resque::Plugin.lint(Resque::Plugins::Lock)
+    end
+
+[sv]: http://semver.org/

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)