resque 1.15.0 → 1.16.0

data/HISTORY.md

@@ -1,3 +1,18 @@
+## 1.16.0 (2011-05-16)
+
+* Optional Hoptoad backend extracted into hoptoad_notifier. Install the gem to use it.
+* Added `Worker#paused?` method
+* Bugfix: Properly reseed random number generator after forking.
+* Bugfix: Resque.redis=(<a Redis::Namespace>)
+* Bugfix: Monit example stdout/stderr redirection
+* Bugfix: Removing single failure now works with multiple failure backends
+* Web: 'Remove Queue' now requires confirmation
+* Web: Favicon!
+* Web Bugfix: Dates display in Safari
+* Web Bugfix: Dates display timezone
+* Web Bugfix: Race condition querying working workers
+* Web Bugfix: Fix polling /workers/all in resque-web
+
 ## 1.15.0 (2011-03-18)
 
 * Fallback to Redis.connect. Makes ENV variables and whatnot work.

data/README.markdown

@@ -47,14 +47,17 @@ later, pull those jobs off the queue and process them.
 Resque jobs are Ruby classes (or modules) which respond to the
 `perform` method. Here's an example:
 
-    class Archive
-      @queue = :file_serve
 
-      def self.perform(repo_id, branch = 'master')
-        repo = Repository.find(repo_id)
-        repo.create_archive(branch)
-      end
-    end
+``` ruby
+class Archive
+  @queue = :file_serve
+
+  def self.perform(repo_id, branch = 'master')
+    repo = Repository.find(repo_id)
+    repo.create_archive(branch)
+  end
+end
+```
 
 The `@queue` class instance variable determines which queue `Archive`
 jobs will be placed in. Queues are arbitrary and created on the fly -
@@ -63,11 +66,13 @@ you can name them whatever you want and have as many as you want.
 To place an `Archive` job on the `file_serve` queue, we might add this
 to our application's pre-existing `Repository` class:
 
-    class Repository
-      def async_create_archive(branch)
-        Resque.enqueue(Archive, self.id, branch)
-      end
-    end
+``` ruby
+class Repository
+  def async_create_archive(branch)
+    Resque.enqueue(Archive, self.id, branch)
+  end
+end
+```
 
 Now when we call `repo.async_create_archive('masterbrew')` in our
 application, a job will be created and placed on the `file_serve`
@@ -75,12 +80,16 @@ queue.
 
 Later, a worker will run something like this code to process the job:
 
-    klass, args = Resque.reserve(:file_serve)
-    klass.perform(*args) if klass.respond_to? :perform
+``` ruby
+klass, args = Resque.reserve(:file_serve)
+klass.perform(*args) if klass.respond_to? :perform
+```
 
 Which translates to:
 
-    Archive.perform(44, 'masterbrew')
+``` ruby
+Archive.perform(44, 'masterbrew')
+```
 
 Let's start a worker to run `file_serve` jobs:
 
@@ -129,25 +138,33 @@ needs to be crunched later into a queue.
 Jobs are persisted to queues as JSON objects. Let's take our `Archive`
 example from above. We'll run the following code to create a job:
 
-    repo = Repository.find(44)
-    repo.async_create_archive('masterbrew')
+``` ruby
+repo = Repository.find(44)
+repo.async_create_archive('masterbrew')
+```
 
 The following JSON will be stored in the `file_serve` queue:
 
-    {
-        'class': 'Archive',
-        'args': [ 44, 'masterbrew' ]
-    }
+``` javascript
+{
+    'class': 'Archive',
+    'args': [ 44, 'masterbrew' ]
+}
+```
 
 Because of this your jobs must only accept arguments that can be JSON encoded.
 
 So instead of doing this:
 
-    Resque.enqueue(Archive, self, branch)
+``` ruby
+Resque.enqueue(Archive, self, branch)
+```
 
 do this:
 
-    Resque.enqueue(Archive, self.id, branch)
+``` ruby
+Resque.enqueue(Archive, self.id, branch)
+```
 
 This is why our above example (and all the examples in `examples/`)
 uses object IDs instead of passing around the objects.
@@ -187,15 +204,17 @@ Workers
 
 Resque workers are rake tasks that run forever. They basically do this:
 
-    start
-    loop do
-      if job = reserve
-        job.process
-      else
-        sleep 5
-      end
-    end
-    shutdown
+``` ruby
+start
+loop do
+  if job = reserve
+    job.process
+  else
+    sleep 5
+  end
+end
+shutdown
+```
 
 Starting a worker is simple. Here's our example from earlier:
 
@@ -214,13 +233,17 @@ This will load the environment before starting a worker. Alternately
 we can define a `resque:setup` task with a dependency on the
 `environment` rake task:
 
-    task "resque:setup" => :environment
+``` ruby
+task "resque:setup" => :environment
+```
 
 GitHub's setup task looks like this:
 
-    task "resque:setup" => :environment do
-      Grit::Git.git_timeout = 10.minutes
-    end
+``` ruby
+task "resque:setup" => :environment do
+  Grit::Git.git_timeout = 10.minutes
+end
+```
 
 We don't want the `git_timeout` as high as 10 minutes in our web app,
 but in the Resque workers it's fine.
@@ -435,11 +458,13 @@ Nginx: <http://www.modrails.com/documentation/Users%20guide%20Nginx.html#deployi
 If you want to load Resque on a subpath, possibly alongside other
 apps, it's easy to do with Rack's `URLMap`:
 
-    require 'resque/server'
+``` ruby
+require 'resque/server'
 
-    run Rack::URLMap.new \
-      "/"       => Your::App.new,
-      "/resque" => Resque::Server.new
+run Rack::URLMap.new \
+  "/"       => Your::App.new,
+  "/resque" => Resque::Server.new
+```
 
 Check `examples/demo/config.ru` for a functional example (including
 HTTP basic auth).
@@ -555,7 +580,9 @@ First install the gem.
 
 Next include it in your application.
 
-    require 'resque'
+``` ruby
+require 'resque'
+```
 
 Now start your application:
 
@@ -566,8 +593,10 @@ That's it! You can now create Resque jobs from within your app.
 To start a worker, create a Rakefile in your app's root (or add this
 to an existing Rakefile):
 
-    require 'your/app'
-    require 'resque/tasks'
+``` ruby
+require 'your/app'
+require 'resque/tasks'
+```
 
 Now:
 
@@ -596,7 +625,9 @@ That's it! You can now create Resque jobs from within your app.
 
 To start a worker, add this to your Rakefile in `RAILS_ROOT`:
 
-    require 'resque/tasks'
+``` ruby
+require 'resque/tasks'
+```
 
 Now:
 
@@ -649,11 +680,13 @@ Here's our `config/resque.yml`:
 
 And our initializer:
 
-    rails_root = ENV['RAILS_ROOT'] || File.dirname(__FILE__) + '/../..'
-    rails_env = ENV['RAILS_ENV'] || 'development'
+``` ruby
+rails_root = ENV['RAILS_ROOT'] || File.dirname(__FILE__) + '/../..'
+rails_env = ENV['RAILS_ENV'] || 'development'
 
-    resque_config = YAML.load_file(rails_root + '/config/resque.yml')
-    Resque.redis = resque_config[rails_env]
+resque_config = YAML.load_file(rails_root + '/config/resque.yml')
+Resque.redis = resque_config[rails_env]
+```
 
 Easy peasy! Why not just use `RAILS_ROOT` and `RAILS_ENV`? Because
 this way we can tell our Sinatra app about the config file:
@@ -665,7 +698,9 @@ Now everyone is on the same page.
 Also, you could disable jobs queueing by setting 'inline' attribute.
 For example, if you want to run all jobs in the same process for cucumber, try:
 
-    Resque.inline = ENV['RAILS_ENV'] == "cucumber"
+``` ruby
+Resque.inline = ENV['RAILS_ENV'] == "cucumber"
+```
 
 
 Plugins and Hooks
@@ -692,7 +727,9 @@ in your Redis server.
 
 Simply use the `Resque.redis.namespace` accessor:
 
-    Resque.redis.namespace = "resque:GitHub"
+``` ruby
+Resque.redis.namespace = "resque:GitHub"
+```
 
 We recommend sticking this in your initializer somewhere after Redis
 is configured.
@@ -723,6 +760,13 @@ of charge. This is **not** used by GitHub in production, so please
 send patches for any tweaks or improvements you can make to it.
 
 
+Questions
+---------
+
+Please add them to the [FAQ](https://github.com/defunkt/resque/wiki/FAQ) or
+ask on the Mailing List. The Mailing List is explained further below
+
+
 Development
 -----------
 

data/lib/resque.rb

@@ -24,14 +24,15 @@ module Resque
   extend self
 
   # Accepts:
-  #   1. A 'hostname:port' string
-  #   2. A 'hostname:port:db' string (to select the Redis db)
-  #   3. A 'hostname:port/namespace' string (to set the Redis namespace)
-  #   4. A redis URL string 'redis://host:port'
+  #   1. A 'hostname:port' String
+  #   2. A 'hostname:port:db' String (to select the Redis db)
+  #   3. A 'hostname:port/namespace' String (to set the Redis namespace)
+  #   4. A Redis URL String 'redis://host:port'
   #   5. An instance of `Redis`, `Redis::Client`, `Redis::DistRedis`,
   #      or `Redis::Namespace`.
   def redis=(server)
-    if server.respond_to? :split
+    case server
+    when String
       if server =~ /redis\:\/\//
         redis = Redis.connect(:url => server, :thread_safe => true)
       else
@@ -43,8 +44,8 @@ module Resque
       namespace ||= :resque
 
       @redis = Redis::Namespace.new(namespace, :redis => redis)
-    elsif server.respond_to? :namespace=
-        @redis = server
+    when Redis::Namespace
+      @redis = server
     else
       @redis = Redis::Namespace.new(:resque, :redis => server)
     end
@@ -136,6 +137,19 @@ module Resque
 
   # Pushes a job onto a queue. Queue name should be a string and the
   # item should be any JSON-able Ruby object.
+  #
+  # Resque works generally expect the `item` to be a hash with the following
+  # keys:
+  #
+  #   class - The String name of the job to run.
+  #    args - An Array of arguments to pass the job. Usually passed
+  #           via `class.to_class.perform(*args)`.
+  #
+  # Example
+  #
+  #   Resque.push('archive', :class => 'Archive', :args => [ 35, 'tar' ])
+  #
+  # Returns nothing
   def push(queue, item)
     watch_queue(queue)
     redis.rpush "queue:#{queue}", encode(item)
@@ -333,3 +347,4 @@ module Resque
     end
   end
 end
+

data/lib/resque/failure/hoptoad.rb

@@ -1,6 +1,8 @@
-require 'net/https'
-require 'builder'
-require 'uri'
+begin
+  require 'hoptoad_notifier'
+rescue LoadError
+  raise "Can't find 'hoptoad_notifier' gem. Please add it to your Gemfile or install it."
+end
 
 module Resque
   module Failure
@@ -10,28 +12,17 @@ module Resque
     #
     #   require 'resque/failure/hoptoad'
     #
-    #   Resque::Failure::Hoptoad.configure do |config|
-    #     config.api_key = 'blah'
-    #     config.secure = true
+    #   Resque::Failure::Multiple.classes = [Resque::Failure::Redis, Resque::Failure::Hoptoad]
+    #   Resque::Failure.backend = Resque::Failure::Multiple
     #
-    #     # optional proxy support
-    #     config.proxy_host = 'x.y.z.t'
-    #     config.proxy_port = 8080
+    # Once you've configured resque to use the Hoptoad failure backend,
+    # you'll want to setup an initializer to configure the Hoptoad.
     #
-    #     # server env support, defaults to RAILS_ENV or RACK_ENV
-    #     config.server_environment = "test"
-    #   end
+    # HoptoadNotifier.configure do |config|
+    #   config.api_key = 'your_key_here'
+    # end
+    # For more information see https://github.com/thoughtbot/hoptoad_notifier
     class Hoptoad < Base
-      # From the hoptoad plugin
-      INPUT_FORMAT = /^([^:]+):(\d+)(?::in `([^']+)')?$/
-
-      class << self
-        attr_accessor :secure, :api_key
-        attr_accessor :proxy_host, :proxy_port, :proxy_user, :proxy_pass
-        attr_accessor :server_environment
-        attr_accessor :host, :port
-        attr_accessor :http_read_timeout, :http_open_timeout
-      end
 
       def self.count
         # We can't get the total # of errors from Hoptoad so we fake it
@@ -39,101 +30,15 @@ module Resque
         Stat[:failed]
       end
 
-      def self.configure
-        yield self
-        Resque::Failure.backend = self
-      end
-
       def save
-        http = use_ssl? ? :https : :http
-        host = self.class.host || 'hoptoadapp.com'
-        port = self.class.port
-        url = URI.parse("#{http}://#{host}:#{port}/notifier_api/v2/notices/")
-
-        request = Net::HTTP::Proxy self.class.proxy_host, self.class.proxy_port,
-                                   self.class.proxy_user, self.class.proxy_pass
-        http = request.new(url.host, url.port)
-        headers = {
-          'Content-type' => 'text/xml',
-          'Accept' => 'text/xml, application/xml'
-        }
-
-        http.read_timeout = self.class.http_read_timeout || 5 # seconds
-        http.open_timeout = self.class.http_open_timeout || 2 # seconds
-
-        http.use_ssl = use_ssl?
-
-        begin
-          response = http.post(url.path, xml, headers)
-        rescue TimeoutError => e
-          log "Timeout while contacting the Hoptoad server."
-        end
-
-        case response
-        when Net::HTTPSuccess then
-          log "Hoptoad Success: #{response.class}"
-        else
-          body = response.body if response.respond_to? :body
-          log "Hoptoad Failure: #{response.class}\n#{body}"
-        end
+        HoptoadNotifier.notify_or_ignore(exception,
+          :parameters => {
+            :payload_class => payload['class'].to_s,
+            :payload_args => payload['args'].inspect
+          }
+        )
       end
 
-      def xml
-        x = Builder::XmlMarkup.new
-        x.instruct!
-        x.notice :version=>"2.0" do
-          x.tag! "api-key", api_key
-          x.notifier do
-            x.name "Resqueue"
-            x.version "0.1"
-            x.url "http://github.com/defunkt/resque"
-          end
-          x.error do
-            x.tag! "class", exception.class.name
-            x.message "#{exception.class.name}: #{exception.message}"
-            x.backtrace do
-              fill_in_backtrace_lines(x)
-            end
-          end
-          x.request do
-            x.url queue.to_s
-            x.component worker.to_s
-            x.params do
-              x.var :key=>"payload_class" do
-                x.text! payload["class"].to_s
-              end
-              x.var :key=>"payload_args" do
-                x.text! payload["args"].to_s
-              end
-            end
-          end
-          x.tag!("server-environment") do
-            x.tag!("environment-name",server_environment)
-            x.tag!("project-root", "RAILS_ROOT")
-          end
-
-        end
-      end
-
-      def fill_in_backtrace_lines(x)
-        Array(exception.backtrace).each do |unparsed_line|
-          _, file, number, method = unparsed_line.match(INPUT_FORMAT).to_a
-          x.line :file => file,:number => number
-        end
-      end
-
-      def use_ssl?
-        self.class.secure
-      end
-
-      def api_key
-        self.class.api_key
-      end
-
-      def server_environment
-        return self.class.server_environment if self.class.server_environment
-        defined?(RAILS_ENV) ? RAILS_ENV : (ENV['RACK_ENV'] || 'development')
-      end
     end
   end
 end

data/lib/resque/failure/multiple.rb

@@ -45,6 +45,10 @@ module Resque
       def self.requeue(*args)
         classes.first.requeue(*args)
       end
+
+      def self.remove(index)
+        classes.each { |klass| klass.remove(index) }
+      end
     end
   end
-end
+end

data/lib/resque/server.rb

@@ -2,6 +2,7 @@ require 'sinatra/base'
 require 'erb'
 require 'resque'
 require 'resque/version'
+require 'time'
 
 module Resque
   class Server < Sinatra::Base
@@ -124,11 +125,27 @@ module Resque
         erb :error, {:layout => false}, :error => "Can't connect to Redis! (#{Resque.redis_id})"
       end
     end
+    
+    def show_for_polling(page)
+      content_type "text/html"
+      @polling = true
+      show(page.to_sym, false).gsub(/\s{1,}/, ' ')
+    end
 
     # to make things easier on ourselves
     get "/?" do
       redirect url_path(:overview)
     end
+    
+    %w( overview workers ).each do |page|
+      get "/#{page}.poll" do
+        show_for_polling(page)
+      end
+      
+      get "/#{page}/:id.poll" do
+        show_for_polling(page)
+      end
+    end
 
     %w( overview queues working workers key ).each do |page|
       get "/#{page}" do
@@ -145,14 +162,6 @@ module Resque
       redirect u('queues')
     end
 
-    %w( overview workers ).each do |page|
-      get "/#{page}.poll" do
-        content_type "text/html"
-        @polling = true
-        show(page.to_sym, false).gsub(/\s{1,}/, ' ')
-      end
-    end
-
     get "/failed" do
       if Resque::Failure.url
         redirect Resque::Failure.url

data/lib/resque/server/views/failed.erb

@@ -22,10 +22,10 @@
         <% else %>
         <dt>Worker</dt>
         <dd>
-          <a href="<%= u(:workers, job['worker']) %>"><%= job['worker'].split(':')[0...2].join(':') %></a> on <b class='queue-tag'><%= job['queue'] %></b > at <b><span class="time"><%= job['failed_at'] %></span></b>
+          <a href="<%= u(:workers, job['worker']) %>"><%= job['worker'].split(':')[0...2].join(':') %></a> on <b class='queue-tag'><%= job['queue'] %></b > at <b><span class="time"><%= Time.parse(job['failed_at']).strftime("%D %T %z") %></span></b>
           <% if job['retried_at'] %>
             <div class='retried'>
-              Retried <b><span class="time"><%= job['retried_at'] %></span></b>
+              Retried <b><span class="time"><%= Time.parse(job['retried_at']).strftime("%D %T %z") %></span></b>
               <a href="<%= u "failed/remove/#{start + index - 1}" %>" class="remove" rel="remove">Remove</a>
             </div>
           <% else %>

data/lib/resque/server/views/queues.erb

@@ -4,7 +4,7 @@
 
   <h1>Pending jobs on <span class='hl'><%= queue %></span></h1>
   <form method="POST" action="<%=u "/queues/#{queue}/remove" %>" class='remove-queue'>
-    <input type='submit' name='' value='Remove Queue' />
+    <input type='submit' name='' value='Remove Queue' onclick='return confirm("Are you absolutely sure? This cannot be undone.");' />
   </form>
   <p class='sub'>Showing <%= start = params[:start].to_i %> to <%= start + 20 %> of <b><%=size = resque.size(queue)%></b> jobs</p>
   <table class='jobs'>

data/lib/resque/server/views/working.erb

@@ -27,8 +27,14 @@
 
 <% else %>
 
-  <% workers = resque.working.reject { |w| w.idle? } %>
-  <h1 class='wi'><%= workers.size %> of <%= resque.workers.size %> Workers Working</h1>
+  <%
+    workers = resque.working
+    jobs = workers.collect {|w| w.job }
+    worker_jobs = workers.zip(jobs)
+    worker_jobs = worker_jobs.reject { |w, j| w.idle? }
+  %>
+
+  <h1 class='wi'><%= worker_jobs.size %> of <%= resque.workers.size %> Workers Working</h1>
   <p class='intro'>The list below contains all workers which are currently running a job.</p>
   <table class='workers'>
     <tr>
@@ -37,15 +43,13 @@
       <th>Queue</th>
       <th>Processing</th>
     </tr>
-    <% if workers.empty? %>
+    <% if worker_jobs.empty? %>
     <tr>
       <td colspan="4" class='no-data'>Nothing is happening right now...</td>
     </tr>
     <% end %>
 
-    <% for worker in workers.sort_by { |w| w.job['run_at'] ? w.job['run_at'] : '' } %>
-      <% job = worker.job %>
-
+    <% worker_jobs.sort_by {|w, j| j['run_at'] ? j['run_at'] : '' }.each do |worker, job| %>
       <tr>
         <td class='icon'><img src="<%=u state = worker.state %>.png" alt="<%= state %>" title="<%= state %>"></td>
         <% host, pid, queues = worker.to_s.split(':') %>

data/lib/resque/version.rb

@@ -1,3 +1,3 @@
 module Resque
-  Version = VERSION = '1.15.0'
+  Version = VERSION = '1.16.0'
 end

data/lib/resque/worker.rb

@@ -116,13 +116,13 @@ module Resque
       loop do
         break if shutdown?
 
-        if not @paused and job = reserve
+        if not paused? and job = reserve
           log "got: #{job.inspect}"
           run_hook :before_fork, job
           working_on job
 
           if @child = fork
-            rand # Reseeding
+            srand # Reseeding
             procline "Forked #{@child} at #{Time.now.to_i}"
             Process.wait
           else
@@ -136,7 +136,7 @@ module Resque
         else
           break if interval.zero?
           log! "Sleeping for #{interval} seconds"
-          procline @paused ? "Paused" : "Waiting for #{@queues.join(',')}"
+          procline paused? ? "Paused" : "Waiting for #{@queues.join(',')}"
           sleep interval
         end
       end
@@ -298,6 +298,11 @@ module Resque
       end
     end
 
+    # are we paused?
+    def paused?
+      @paused
+    end
+    
     # Stop processing jobs after the current one has completed (if we're
     # currently running one).
     def pause_processing

data/test/hoptoad_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+begin
+  require 'hoptoad_notifier'
+rescue LoadError
+  warn "Install hoptoad_notifier gem to run Hoptoad tests."
+end
+
+if defined? HoptoadNotifier
+  context "Hoptoad" do
+    test "should be notified of an error" do
+      exception = StandardError.new("BOOM")
+      worker = Resque::Worker.new(:test)
+      queue = "test"
+      payload = {'class' => Object, 'args' => 66}
+
+      HoptoadNotifier.expects(:notify_or_ignore).with(
+        exception,
+        :parameters => {:payload_class => 'Object', :payload_args => '66'})
+
+      backend = Resque::Failure::Hoptoad.new(exception, worker, queue, payload)
+      backend.save
+    end
+  end
+end

data/test/resque_test.rb

@@ -16,6 +16,15 @@ context "Resque" do
     assert_equal 'namespace', Resque.redis.namespace
   end
 
+  test "redis= works correctly with a Redis::Namespace param" do
+    new_redis = Redis.new(:host => "localhost", :port => 9736)
+    new_namespace = Redis::Namespace.new("namespace", :redis => new_redis)
+    Resque.redis = new_namespace
+    assert_equal new_namespace, Resque.redis
+
+    Resque.redis = 'localhost:9736/namespace'
+  end
+
   test "can put jobs on a queue" do
     assert Resque::Job.create(:jobs, 'SomeJob', 20, '/tmp')
     assert Resque::Job.create(:jobs, 'SomeJob', 20, '/tmp')

data/test/test_helper.rb

@@ -1,9 +1,12 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup(:default, :test)
+Bundler.require(:default, :test)
+
 dir = File.dirname(File.expand_path(__FILE__))
 $LOAD_PATH.unshift dir + '/../lib'
 $TESTING = true
 require 'test/unit'
-require 'rubygems'
-require 'resque'
 
 begin
   require 'leftright'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: resque
 version: !ruby/object:Gem::Version 
-  hash: 43
-  prerelease: false
+  hash: 87
+  prerelease: 
   segments: 
   - 1
-  - 15
+  - 16
   - 0
-  version: 1.15.0
+  version: 1.16.0
 platform: ruby
 authors: 
 - Chris Wanstrath
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-19 00:00:00 -07:00
+date: 2011-05-16 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -24,14 +24,14 @@ dependencies:
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 55
+        hash: 19
         segments: 
+        - 1
         - 0
-        - 10
-        - 0
-        version: 0.10.0
+        - 2
+        version: 1.0.2
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -72,7 +72,7 @@ dependencies:
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
         hash: 11
         segments: 
@@ -80,6 +80,13 @@ dependencies:
         - 4
         - 6
         version: 1.4.6
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 1
+        - 6
+        version: "1.6"
   type: :runtime
   version_requirements: *id004
 description: "    Resque is a Redis-backed Ruby library for creating background jobs,\n    placing those jobs on multiple queues, and processing them later.\n\n    Background jobs can be any Ruby class or module that responds to\n    perform. Your existing classes can easily be converted to background\n    jobs or you can create new classes specifically to do work. Or, you\n    can do both.\n\n    Resque is heavily inspired by DelayedJob (which rocks) and is\n    comprised of three parts:\n\n    * A Ruby library for creating, querying, and processing jobs\n    * A Rake task for starting a worker which processes jobs\n    * A Sinatra app for monitoring queues, jobs, and workers.\n"
@@ -106,6 +113,7 @@ files:
 - lib/resque/helpers.rb
 - lib/resque/job.rb
 - lib/resque/plugin.rb
+- lib/resque/server/public/favicon.ico
 - lib/resque/server/public/idle.png
 - lib/resque/server/public/jquery-1.3.2.min.js
 - lib/resque/server/public/jquery.relatize_date.js
@@ -132,8 +140,11 @@ files:
 - lib/resque/version.rb
 - lib/resque/worker.rb
 - lib/resque.rb
+- lib/tasks/redis.rake
+- lib/tasks/resque.rake
 - bin/resque
 - bin/resque-web
+- test/hoptoad_test.rb
 - test/job_hooks_test.rb
 - test/job_plugins_test.rb
 - test/plugin_test.rb
@@ -142,8 +153,6 @@ files:
 - test/resque_test.rb
 - test/test_helper.rb
 - test/worker_test.rb
-- tasks/redis.rake
-- tasks/resque.rake
 has_rdoc: true
 homepage: http://github.com/defunkt/resque
 licenses: []
@@ -174,7 +183,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.5.2
 signing_key: 
 specification_version: 3
 summary: Resque is a Redis-backed queueing system.