Merge branch 'master' into 2.0

Conflicts:
	HISTORY.md

Author: defunkt

.gitignore

@@ -1,3 +1,2 @@
-*.gemspec
 pkg
 nbproject

HISTORY.md

@@ -2,6 +2,16 @@
 
 * Resque now uses Unix Epoch Timestamps exclusively.
 
+## 1.8.0 (2010-04-07)
+
+* Jobs that never complete due to killed worker are now failed.
+* Worker "working" state is now maintained by the parent, not the child.
+* Stopped using deprecated redis.rb methods
+* `Worker.working` race condition fixed
+* `Worker#process` has been deprecated.
+* Monit example fixed
+* Redis::Client and Redis::Namespace can be passed to `Resque.redis=`
+
 ## 1.7.1 (2010-04-02)
 
 * Bugfix: Make job hook execution order consistent

Rakefile

@@ -42,47 +42,12 @@ end
 
 task :install => [ 'redis:install', 'dtach:install' ]
 
-desc "Build a gem"
-task :gem => [ :test, :gemspec, :build ]
-
 begin
-  require 'jeweler'
-  require 'resque/version'
-
-  Jeweler::Tasks.new do |gemspec|
-    gemspec.name = "resque"
-    gemspec.summary = "Resque is a Redis-backed queueing system."
-    gemspec.email = "[email protected]"
-    gemspec.homepage = "http://github.com/defunkt/resque"
-    gemspec.authors = ["Chris Wanstrath"]
-    gemspec.version = Resque::Version
-
-    gemspec.add_dependency "redis"
-    gemspec.add_dependency "redis-namespace"
-    gemspec.add_dependency "vegas", ">=0.1.2"
-    gemspec.add_dependency "sinatra", ">=0.9.2"
-    gemspec.add_development_dependency "jeweler"
-
-    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
+  require 'mg'
+  MG.new("resque.gemspec")
 rescue LoadError
-  puts "Jeweler not available. Install it with: "
-  puts "gem install jeweler"
+  warn "mg not available."
+  warn "Install it with: gem i mg"
 end
 
 
@@ -102,11 +67,12 @@ 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"
+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

lib/resque.rb

@@ -26,15 +26,16 @@ module Resque
   # Accepts:
   #   1. A 'hostname:port' string
   #   2. A 'hostname:port:db' string (to select the Redis db)
-  #   3. An instance of `Redis`, `Redis::Client`, or `Redis::Namespace`.
+  #   3. An instance of `Redis`, `Redis::Client`, `Redis::DistRedis`,
+  #      or `Redis::Namespace`.
   def redis=(server)
     case server
     when String
       host, port, db = server.split(':')
       redis = Redis.new(:host => host, :port => port,
         :thread_safe => true, :db => db)
       @redis = Redis::Namespace.new(:resque, :redis => redis)
-    when Redis, Redis::Client
+    when Redis, Redis::Client, Redis::DistRedis
       @redis = Redis::Namespace.new(:resque, :redis => server)
     when Redis::Namespace
       @redis = server

lib/resque/failure/multiple.rb

@@ -3,23 +3,23 @@ module Failure
     # A Failure backend that uses multiple backends
     # delegates all queries to the first backend
     class Multiple < Base
-      
+
       class << self
         attr_accessor :classes
       end
-      
+
       def self.configure
         yield self
         Resque::Failure.backend = self
       end
-      
+
       def initialize(*args)
         @backends = self.class.classes.map {|klass| klass.new(*args)}
       end
       def save
         @backends.each(&:save)
       end
-      
+
       # The number of failures.
       def self.count
         classes.first.count
@@ -34,11 +34,15 @@ def self.all(start = 0, count = 1)
       def self.url
         classes.first.url
       end
-      
+
       # Clear all failure objects
       def self.clear
         classes.first.clear
       end
+
+      def self.requeue(*args)
+        classes.first.requeue(*args)
+      end
     end
   end
 end

lib/resque/server/views/failed.erb

@@ -35,8 +35,12 @@
         <dd><code><%= job['exception'] %></code></dd>
         <dt>Error</dt>
         <dd class='error'>
-          <a href="#" class="backtrace"><%= h(job['error']) %></a>
-          <pre style='display:none'><%=h job['backtrace'].join("\n") %></pre>
+          <% if job['backtrace'] %>
+            <a href="#" class="backtrace"><%= h(job['error']) %></a>
+            <pre style='display:none'><%=h job['backtrace'].join("\n") %></pre>
+          <% else %>
+            <%=h job['error'] %>
+          <% end %>
         </dd>
       </dl>
       <div class='r'>

lib/resque/version.rb

@@ -1,3 +1,3 @@
 module Resque
-  Version = '1.7.1'
+  Version = '1.8.0'
 end

lib/resque/worker.rb

@@ -113,17 +113,19 @@ def work(interval = 5, &block)
         if not @paused and job = reserve
           log "got: #{job.inspect}"
           run_hook :before_fork
+          working_on job
 
           if @child = fork
             rand # Reseeding
             procline "Forked #{@child} at #{Time.now.to_i}"
             Process.wait
           else
             procline "Processing #{job.queue} since #{Time.now.to_i}"
-            process(job, &block)
+            perform(job, &block)
             exit! unless @cant_fork
           end
 
+          done_working
           @child = nil
         else
           break if interval.to_i == 0
@@ -137,15 +139,21 @@ def work(interval = 5, &block)
       unregister_worker
     end
 
-    # Processes a single job. If none is given, it will try to produce
-    # one.
-    def process(job = nil)
+    # DEPRECATED. Processes a single job. If none is given, it will
+    # try to produce one. Usually run in the child.
+    def process(job = nil, &block)
       return unless job ||= reserve
 
+      working_on job
+      perform(job, &block)
+    ensure
+      done_working
+    end
+
+    # Processes a given job in the child.
+    def perform(job)
       begin
-        job.worker = self
         run_hook :after_fork, job
-        working_on job
         job.perform
       rescue Object => e
         log "#{job.inspect} failed: #{e.inspect}"
@@ -155,7 +163,6 @@ def process(job = nil)
         log "done: #{job.inspect}"
       ensure
         yield job if block_given?
-        done_working
       end
     end
 
@@ -348,6 +355,7 @@ def unregister_worker
     # Given a job, tells Redis we're working on it. Useful for seeing
     # what workers are doing and when.
     def working_on(job)
+      job.worker = self
       data = encode \
         :queue   => job.queue,
         :run_at  => Time.now.to_i,

resque.gemspec

@@ -0,0 +1,43 @@
+require 'resque/version'
+
+Gem::Specification.new do |s|
+  s.name              = "resque"
+  s.version           = Resque::Version
+  s.date              = Time.now.strftime('%Y-%m-%d')
+  s.summary           = "Resque is a Redis-backed queueing system."
+  s.homepage          = "http://github.com/defunkt/mustache"
+  s.email             = "[email protected]"
+  s.authors           = [ "Chris Wanstrath" ]
+
+  s.files             = %w( README.markdown Rakefile LICENSE )
+  s.files            += Dir.glob("lib/**/*")
+  s.files            += Dir.glob("bin/**/*")
+  s.files            += Dir.glob("man/**/*")
+  s.files            += Dir.glob("test/**/*")
+  s.executables       = [ "resque", "resque-web" ]
+
+  s.extra_rdoc_files  = [ "LICENSE", "README.markdown" ]
+  s.rdoc_options      = ["--charset=UTF-8"]
+
+  s.add_dependency "redis"
+  s.add_dependency "redis-namespace"
+  s.add_dependency "vegas",   ">= 0.1.2"
+  s.add_dependency "sinatra", ">= 0.9.2"
+
+  s.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

test/resque_test.rb

@@ -202,6 +202,7 @@
     @worker = Resque::Worker.new(:jobs)
     @worker.register_worker
     2.times { @worker.process }
+
     job = @worker.reserve
     @worker.working_on job