resque-retry 0.1.0 → 0.2.1

data/HISTORY.md

@@ -1,3 +1,24 @@
+## 0.2.1 (2011-11-23)
+
+* Bugfix: Fixed error when we tried to parse a number/string as JSON on the
+  reque-retry web interface.
+
+## 0.2.0 (2011-11-22)
+
+**INCLUDES NON-BACKWARDS COMPATIBLE CHANGES**
+
+* IMPORTANT: `retry_limit` behaviour has changed. (Nicolas Fouché)
+    PREVIOUSLY: 0 == infinite retries.
+           NOW: -1 == infinite retries; 0 == means never retry.
+
+* Bugfix: `#redis_retry_key` incorrectly built key when custom identifier
+  was used. (Bogdan Gusiev)
+* Feature: Ability to sleep worker after re-queuing a job, may be used to bias
+  against the same worker from picking up the job again. (Michael Keirnan)
+* Feature: Ability to remove retry jobs using resque-web. (Thiago Morello)
+* Added example demo application.
+* Added Bundler `Gemfile`.
+
 ## 0.1.0 (2010-08-29)
 
 * Feature: Multiple failure backend with retry suppression.
@@ -30,4 +51,4 @@
 
 ## 0.0.1 (2010-04-27)
 
-* First release.
+* First release.

data/README.md

@@ -1,7 +1,7 @@
 resque-retry
 ============
 
-A [Resque][rq] plugin. Requires Resque 1.8.0 & [resque-scheduler][rqs].
+A [Resque][rq] plugin. Requires Resque >= 1.8.0 & [resque-scheduler][rqs].
 
 resque-retry provides retry, delay and exponential backoff support for
 resque jobs.
@@ -19,7 +19,7 @@ To install:
 
     $ gem install resque-retry
 
-You'll want add this to your `Rakefile`:
+Add this to your `Rakefile`:
 
     require 'resque/tasks'
     require 'resque_scheduler/tasks'
@@ -118,7 +118,7 @@ some ideas =), adapt for your own usage and feel free to pick and mix!
 
 Retry the job **once** on failure, with zero delay.
 
-    require 'require-retry'
+    require 'resque-retry'
 
     class DeliverWebHook
       extend Resque::Plugins::Retry
@@ -147,12 +147,37 @@ determine if we can requeue the job for another go.
       end
     end
 
-The above modification will allow your job to retry upto 10 times, with
+The above modification will allow your job to retry up to 10 times, with
 a delay of 120 seconds, or 2 minutes between retry attempts.
 
 Alternatively you could override the `retry_delay` method to do something
 more special.
 
+### Sleep After Requeuing
+
+Sometimes it is useful to delay the worker that failed a job attempt, but still requeue the job for immediate processing
+by other workers. This can be done with `@sleep_after_requeue`:
+
+    class DeliverWebHook
+      extend Resque::Plugins::Retry
+      @queue = :web_hooks
+
+      @sleep_after_requeue = 5
+
+      def self.perform(url, hook_id, hmac_key)
+        heavy_lifting
+      end
+    end
+
+This retries the job once and causes the worker that failed to sleep for 5 seconds after requeuing the job.  If there are
+multiple workers in the system this allows the job to be retried immediately while the original worker heals itself.  For
+example failed jobs may cause other (non-worker) OS processes to die.  A system monitor such as [god][god] can fix
+the server while the job is being retried on a different worker.
+
+`@sleep_after_requeue` is independent of `@retry_delay`.  If you set both, they both take effect.
+
+You can override the method `sleep_after_requeue` to set the sleep value dynamically.
+
 ### Exponential Backoff
 
 Use this if you wish to vary the delay between retry attempts:
@@ -176,7 +201,7 @@ Use this if you wish to vary the delay between retry attempts:
 The first delay will be 0 seconds, the 2nd will be 60 seconds, etc...
 Again, tweak to your own needs.
 
-The number if retrys is equal to the size of the `backoff_strategy`
+The number of retries is equal to the size of the `backoff_strategy`
 array, unless you set `retry_limit` yourself.
 
 ### Retry Specific Exceptions
@@ -285,5 +310,6 @@ Contributing/Pull Requests
   * Send me a pull request. Bonus points for topic branches.
   * If you edit the gemspec/version etc, do it in another commit please.
 
+[god]: http://github.com/mojombo/god
 [rq]: http://github.com/defunkt/resque
 [rqs]: http://github.com/bvandenbos/resque-scheduler

data/lib/resque-retry.rb

@@ -3,4 +3,4 @@ require 'resque_scheduler'
 
 require 'resque/plugins/retry'
 require 'resque/plugins/exponential_backoff'
-require 'resque/failure/multiple_with_retry_suppression'
+require 'resque/failure/multiple_with_retry_suppression'

data/lib/resque-retry/server.rb

@@ -1,3 +1,5 @@
+require 'cgi'
+
 # Extend Resque::Server to add tabs.
 module ResqueRetry
   module Server
@@ -22,7 +24,7 @@ module ResqueRetry
           
           # gets the failure details hash for a job.
           def retry_failure_details(retry_key)
-            Resque.decode(Resque.redis["failure_#{retry_key}"])
+            Resque.decode(Resque.redis.get("failure_#{retry_key}"))
           end
 
           # reads a 'local' template file.
@@ -30,6 +32,16 @@ module ResqueRetry
             # Is there a better way to specify alternate template locations with sinatra?
             File.read(File.join(File.dirname(__FILE__), "server/views/#{path}"))
           end
+
+          # Cancels job retry
+          #
+          def cancel_retry(job)
+            klass = Resque.constantize(job['class'])
+            retry_key = retry_key_for_job(job)
+            Resque.remove_delayed(klass, *job['args'])
+            Resque.redis.del("failure_#{retry_key}")
+            Resque.redis.del(retry_key)
+          end
         end
 
         get '/retry' do
@@ -39,6 +51,19 @@ module ResqueRetry
         get '/retry/:timestamp' do
           erb local_template('retry_timestamp.erb')
         end
+
+        post '/retry/:timestamp/remove' do
+          Resque.delayed_timestamp_peek(params[:timestamp], 0, 0).each do |job|
+            cancel_retry(job)
+          end
+          redirect u('retry')
+        end
+
+        post '/retry/:timestamp/jobs/:id/remove' do
+          job = Resque.decode(params[:id])
+          cancel_retry(job)
+          redirect u("retry/#{params[:timestamp]}")
+        end
       }
     end
 

data/lib/resque-retry/server/views/retry.erb

@@ -22,9 +22,14 @@
   <% timestamps = resque.delayed_queue_peek(start, start+20) %>
   <% timestamps.each do |timestamp| %>
     <% job = resque.delayed_timestamp_peek(timestamp, 0, 1).first %>
+    <% next unless job %>
     <% retry_key = retry_key_for_job(job) %>
     <tr>
       <td>
+        <form action="<%= url "retry/#{timestamp}/remove" %>" method="post">
+          <input type="hidden" name="timestamp" value="<%= timestamp.to_i %>">
+          <input type="submit" value="Remove">
+        </form>
         <form action="<%= url "/delayed/queue_now" %>" method="post">
           <input type="hidden" name="timestamp" value="<%= timestamp.to_i %>">
           <input type="submit" value="Queue now">
@@ -45,4 +50,4 @@
   <% end %>
 </table>
 
-<%= partial :next_more, :start => start, :size => size %>
+<%= partial :next_more, :start => start, :size => size %>

data/lib/resque-retry/server/views/retry_timestamp.erb

@@ -22,6 +22,7 @@
     <th>Retry Attempts</th>
     <th>Exception</th>
     <th>Backtrace</th>
+    <th>Actions</th>
   </tr>
   <% jobs = resque.delayed_timestamp_peek(timestamp, start, 20) %>
   <% jobs.each do |job| %>
@@ -35,21 +36,31 @@
       <% else %>
         <td><%= retry_attempts %></td>
         <% failure = retry_failure_details(retry_key) %>
-        <td><code><%= failure['exception'] %></code></td>
-        <td class="error">
-          <% if failure['backtrace'] %>
-            <a href="#" class="backtrace"><%= h(failure['error']) %></a>
-            <pre style="display:none"><%= h failure['backtrace'].join("\n") %></pre>
-          <% else %>
-            <%= h failure['error'] %>
-          <% end %>
-        </td>
+        <% if failure.nil? %>
+          <td colspan="2"><i>n/a - not using resque-retry failure backend</i></td>
+        <% else %>
+          <td><code><%= failure['exception'] %></code></td>
+          <td class="error">
+            <% if failure['backtrace'] %>
+              <a href="#" class="backtrace"><%= h(failure['error']) %></a>
+              <pre style="display:none"><%= h failure['backtrace'].join("\n") %></pre>
+            <% else %>
+              <%= h failure['error'] %>
+            <% end %>
+          </td>
+        <% end %>
       <% end %>
+      <td>
+        <form action="<%= url "retry/#{timestamp}/jobs/#{CGI.escape(Resque.encode(job))}/remove" %>" method="post">
+          <input type="hidden" name="timestamp" value="<%= timestamp.to_i %>">
+          <input type="submit" value="Remove">
+        </form>
+      </td>
     </tr>
   <% end %>
   <% if jobs.empty? %>
     <tr>
-      <td class="no-data" colspan="5">
+      <td class="no-data" colspan="6">
         There are no pending jobs scheduled for this time.
       </td>
     </tr>

data/lib/resque/failure/multiple_with_retry_suppression.rb

@@ -19,27 +19,16 @@ module Resque
     class MultipleWithRetrySuppression < Multiple
       include Resque::Helpers
 
-      module CleanupHooks
-        # Resque after_perform hook.
-        #
-        # Deletes retry failure information from Redis.
-        def after_perform_retry_failure_cleanup(*args)
-          retry_key = redis_retry_key(*args)
-          failure_key = Resque::Failure::MultipleWithRetrySuppression.failure_key(retry_key)
-          Resque.redis.del(failure_key)
-        end
-      end
-
       # Called when the job fails.
       #
       # If the job will retry, suppress the failure from the other backends.
       # Store the lastest failure information in redis, used by the web
       # interface.
       def save
-        unless retryable? && retrying?
+        if ! (retryable? && retrying?)
           cleanup_retry_failure_log!
           super
-        else
+        elsif retry_delay > 0
           data = {
             :failed_at => Time.now.strftime("%Y/%m/%d %H:%M:%S"),
             :payload   => payload,
@@ -50,12 +39,7 @@ module Resque
             :queue     => queue
           }
 
-          # Register cleanup hooks.
-          unless klass.respond_to?(:after_perform_retry_failure_cleanup)
-            klass.send(:extend, CleanupHooks)
-          end
-
-          redis[failure_key] = Resque.encode(data)
+          redis.setex(failure_key, 2*retry_delay, Resque.encode(data))
         end
       end
 
@@ -69,8 +53,12 @@ module Resque
         constantize(payload['class'])
       end
 
+      def retry_delay
+        klass.retry_delay
+      end
+
       def retry_key
-        klass.redis_retry_key(payload['args'])
+        klass.redis_retry_key(*payload['args'])
       end
 
       def failure_key
@@ -79,6 +67,8 @@ module Resque
 
       def retryable?
         klass.respond_to?(:redis_retry_key)
+      rescue NameError
+        false
       end
 
       def retrying?

data/lib/resque/plugins/retry.rb

@@ -63,7 +63,9 @@ module Resque
       end
 
       # Maximum number of retrys we can attempt to successfully perform the job.
-      # A retry limit of 0 or below will retry forever.
+      #
+      # A retry limit of 0 will *never* retry.
+      # A retry limit of -1 or below will retry forever.
       #
       # @return [Fixnum]
       def retry_limit
@@ -88,6 +90,14 @@ module Resque
         @retry_delay ||= 0
       end
 
+      # @abstract
+      # Number of seconds to sleep after job is requeued
+      # 
+      # @return [Number] number of seconds to sleep
+      def sleep_after_requeue
+        @sleep_after_requeue ||= 0
+      end
+      
       # @abstract
       # Modify the arguments used to retry the job. Use this to do something
       # other than try the exact same job again.
@@ -147,10 +157,13 @@ module Resque
       #
       # @return [Boolean]
       def retry_limit_reached?
-        if retry_limit > 0
-          return true if retry_attempt >= retry_limit
+        if retry_limit == 0
+          true
+        elsif retry_limit > 0
+          true if retry_attempt >= retry_limit
+        else
+          false
         end
-        false
       end
 
       # Register a retry criteria check callback to be run before retrying
@@ -177,7 +190,7 @@ module Resque
         retry_criteria_checks << block
       end
 
-      # Will retry the job.
+      # Retries the job.
       def try_again(*args)
         if retry_delay <= 0
           # If the delay is 0, no point passing it through the scheduler
@@ -185,6 +198,7 @@ module Resque
         else
           Resque.enqueue_in(retry_delay, self, *args_for_retry(*args))
         end
+        sleep(sleep_after_requeue) if sleep_after_requeue > 0
       end
 
       # Resque before_perform hook.

data/test/exponential_backoff_test.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/test_helper'
 
-class ExponentialBackoffTest < Test::Unit::TestCase
+class ExponentialBackoffTest < MiniTest::Unit::TestCase
   def setup
     Resque.redis.flushall
     @worker = Resque::Worker.new(:testing)
@@ -8,9 +8,8 @@ class ExponentialBackoffTest < Test::Unit::TestCase
   end
 
   def test_resque_plugin_lint
-    assert_nothing_raised do
-      Resque::Plugin.lint(Resque::Plugins::ExponentialBackoff)
-    end
+    # will raise exception if were not a good plugin.
+    assert Resque::Plugin.lint(Resque::Plugins::ExponentialBackoff)
   end
 
   def test_default_backoff_strategy
@@ -19,7 +18,7 @@ class ExponentialBackoffTest < Test::Unit::TestCase
 
     perform_next_job @worker
     assert_equal 1, Resque.info[:processed], '1 processed job'
-    assert_equal 1, Resque.info[:failed], 'first ever run, and it should of failed, but never retried'
+    assert_equal 1, Resque.info[:failed], 'first ever run, and it should have failed, but never retried'
     assert_equal 1, Resque.info[:pending], '1 pending job, because it never hits the scheduler'
 
     perform_next_job @worker

data/test/multiple_failure_test.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/test_helper'
 
-class MultipleFailureTest < Test::Unit::TestCase
+class MultipleFailureTest < MiniTest::Unit::TestCase
   def setup
     Resque.redis.flushall
     @worker = Resque::Worker.new(:testing)
@@ -17,42 +17,35 @@ class MultipleFailureTest < Test::Unit::TestCase
     key = "failure_" + klass.redis_retry_key(args)
   end
 
-  def test_last_failure_is_saved_in_redis
-    Resque.enqueue(LimitThreeJob)
+  def test_last_failure_is_saved_in_redis_if_delay
+    Resque.enqueue(LimitThreeJobDelay1Hour)
     perform_next_job(@worker)
 
     # I don't like this, but...
-    key = failure_key_for(LimitThreeJob)
+    key = failure_key_for(LimitThreeJobDelay1Hour)
     assert Resque.redis.exists(key)
   end
 
-  def test_last_failure_removed_from_redis_after_error_limit
-    Resque.enqueue(LimitThreeJob)
-    3.times do
-      perform_next_job(@worker)
-    end
-
-    key = failure_key_for(LimitThreeJob)
-    assert Resque.redis.exists(key)
 
+  def test_last_failure_has_double_delay_redis_expiry_if_delay
+    Resque.enqueue(LimitThreeJobDelay1Hour)
     perform_next_job(@worker)
-    assert !Resque.redis.exists(key)
+
+    # I don't like this, but...
+    key = failure_key_for(LimitThreeJobDelay1Hour)
+    assert_equal 7200, Resque.redis.ttl(key)
   end
 
-  def test_on_success_failure_log_removed_from_redis
-    SwitchToSuccessJob.successful_after = 1
-    Resque.enqueue(SwitchToSuccessJob)
+  def test_last_failure_is_not_saved_in_redis_if_no_delay
+    Resque.enqueue(LimitThreeJob)
     perform_next_job(@worker)
 
-    key = failure_key_for(SwitchToSuccessJob)
-    assert Resque.redis.exists(key)
-
-    perform_next_job(@worker)
-    assert !Resque.redis.exists(key), 'key removed on success'
-  ensure
-    SwitchToSuccessJob.reset_defaults
+    # I don't like this, but...
+    key = failure_key_for(LimitThreeJob)
+    assert !Resque.redis.exists(key)
   end
 
+
   def test_errors_are_suppressed_up_to_retry_limit
     Resque.enqueue(LimitThreeJob)
     3.times do
@@ -80,6 +73,14 @@ class MultipleFailureTest < Test::Unit::TestCase
     assert_equal 5, MockFailureBackend.errors.size
   end
 
+  def test_custom_identifier_job
+    Resque.enqueue(CustomIdentifierFailingJob, 'qq', 2)
+    4.times do
+      perform_next_job(@worker)
+    end
+    assert_equal 1, MockFailureBackend.errors.size
+  end
+
   def teardown
     Resque::Failure.backend = @old_failure_backend
   end

data/test/redis-test.conf

@@ -112,21 +112,4 @@ databases 16
 # Glue small output buffers together in order to send small replies in a
 # single TCP packet. Uses a bit more CPU but most of the times it is a win
 # in terms of number of queries per second. Use 'yes' if unsure.
-glueoutputbuf yes
-
-# Use object sharing. Can save a lot of memory if you have many common
-# string in your dataset, but performs lookups against the shared objects
-# pool so it uses more CPU and can be a bit slower. Usually it's a good
-# idea.
-#
-# When object sharing is enabled (shareobjects yes) you can use
-# shareobjectspoolsize to control the size of the pool used in order to try
-# object sharing. A bigger pool size will lead to better sharing capabilities.
-# In general you want this value to be at least the double of the number of
-# very common strings you have in your dataset.
-#
-# WARNING: object sharing is experimental, don't enable this feature
-# in production before of Redis 1.0-stable. Still please try this feature in
-# your development environment so that we can test it better.
-# shareobjects no
-# shareobjectspoolsize 1024
+glueoutputbuf yes

data/test/resque_test.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/test_helper'
 
 # make sure the worlds not fallen from beneith us.
-class ResqueTest < Test::Unit::TestCase
+class ResqueTest < MiniTest::Unit::TestCase
   def test_resque_version
     major, minor, patch = Resque::Version.split('.')
     assert_equal 1, major.to_i, 'major version does not match'

data/test/retry_criteria_test.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/test_helper'
 
-class RetryCriteriaTest < Test::Unit::TestCase
+class RetryCriteriaTest < MiniTest::Unit::TestCase
   def setup
     Resque.redis.flushall
     @worker = Resque::Worker.new(:testing)

data/test/retry_inheriting_checks_test.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/test_helper'
 
-class RetryInheritingChecksTest < Test::Unit::TestCase
+class RetryInheritingChecksTest < MiniTest::Unit::TestCase
   def setup
     Resque.redis.flushall
     @worker = Resque::Worker.new(:testing)

data/test/retry_test.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/test_helper'
 
-class RetryTest < Test::Unit::TestCase
+class RetryTest < MiniTest::Unit::TestCase
   def setup
     Resque.redis.flushall
     @worker = Resque::Worker.new(:testing)
@@ -8,16 +8,15 @@ class RetryTest < Test::Unit::TestCase
   end
 
   def test_resque_plugin_lint
-    assert_nothing_raised do
-      Resque::Plugin.lint(Resque::Plugins::Retry)
-    end
+    # will raise exception if were not a good plugin.
+    assert Resque::Plugin.lint(Resque::Plugins::Retry)
   end
 
   def test_default_settings
-    assert_equal 1, RetryDefaultsJob.retry_limit, 'default retry limit'
-    assert_equal 0, RetryDefaultsJob.retry_attempt, 'default number of retry attempts'
-    assert_equal nil, RetryDefaultsJob.retry_exceptions, 'default retry exceptions; nil = any'
-    assert_equal 0, RetryDefaultsJob.retry_delay, 'default seconds until retry'
+    assert_equal 1, RetryDefaultSettingsJob.retry_limit, 'default retry limit'
+    assert_equal 0, RetryDefaultSettingsJob.retry_attempt, 'default number of retry attempts'
+    assert_equal nil, RetryDefaultSettingsJob.retry_exceptions, 'default retry exceptions; nil = any'
+    assert_equal 0, RetryDefaultSettingsJob.retry_delay, 'default seconds until retry'
   end
 
   def test_retry_once_by_default
@@ -71,6 +70,17 @@ class RetryTest < Test::Unit::TestCase
     assert_equal 10, Resque.info[:processed], 'processed job'
   end
 
+  def test_retry_never_retry
+    Resque.enqueue(NeverRetryJob)
+    10.times do
+      perform_next_job(@worker)
+    end
+
+    assert_equal 0, Resque.info[:pending], 'pending jobs'
+    assert_equal 1, Resque.info[:failed], 'failed jobs'
+    assert_equal 1, Resque.info[:processed], 'processed job'
+  end
+
   def test_fail_five_times_then_succeed
     Resque.enqueue(FailFiveTimesJob)
     7.times do
@@ -82,6 +92,22 @@ class RetryTest < Test::Unit::TestCase
     assert_equal 0, Resque.info[:pending], 'pending jobs'
   end
 
+  def test_retry_delay_sleep
+    assert_equal 0, Resque.info[:failed], 'failed jobs'
+    Resque.enqueue(SleepDelay1SecondJob)
+    before = Time.now
+    3.times do
+      perform_next_job(@worker)
+    end
+    actual_delay = Time.now - before
+    
+    assert actual_delay >= 1, "did not sleep long enough: #{actual_delay} seconds"
+    assert actual_delay < 2, "slept too long: #{actual_delay} seconds"
+    assert_equal 1, Resque.info[:failed], 'failed jobs'
+    assert_equal 2, Resque.info[:processed], 'processed job'
+    assert_equal 0, Resque.info[:pending], 'pending jobs'
+  end
+  
   def test_can_determine_if_exception_may_be_retried
     assert_equal true, RetryDefaultsJob.retry_exception?(StandardError), 'StandardError may retry'
     assert_equal true, RetryDefaultsJob.retry_exception?(CustomException), 'CustomException may retry'

data/test/server_test.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+require 'resque-retry/server'
+ENV['RACK_ENV'] = 'test'
+
+# Testing the Resque web interface additions.
+class ServerTest < MiniTest::Unit::TestCase
+  include Rack::Test::Methods
+
+  def app
+    Resque::Server
+  end
+
+  # make sure the world looks okay first =)
+  def test_were_able_to_access_normal_resque_web_overview
+    get '/overview'
+    assert_equal 200, last_response.status, 'HTTP status code should be 200'
+  end
+
+  def test_should_include_retry_tab
+    get '/overview'
+    assert last_response.body.include?('/retry')
+  end
+
+end

data/test/test_helper.rb

@@ -2,10 +2,10 @@ dir = File.dirname(File.expand_path(__FILE__))
 $LOAD_PATH.unshift dir + '/../lib'
 $TESTING = true
 
-require 'test/unit'
-require 'rubygems'
-require 'turn'
-require 'simplecov-html'
+require 'minitest/unit'
+require 'minitest/pride'
+require 'rack/test'
+require 'simplecov'
 
 SimpleCov.start do
   add_filter "/test/"
@@ -59,7 +59,7 @@ class MockFailureBackend < Resque::Failure::Base
 end
 
 # Test helpers
-class Test::Unit::TestCase
+class MiniTest::Unit::TestCase
   def perform_next_job(worker, &block)
     return unless job = @worker.reserve
     @worker.perform(job, &block)

data/test/test_jobs.rb

@@ -13,6 +13,15 @@ end
 class GoodJob
   extend Resque::Plugins::Retry
   @queue = :testing
+
+  def self.perform(*args)
+  end
+end
+
+class RetryDefaultSettingsJob
+  extend Resque::Plugins::Retry
+  @queue = :testing
+
   def self.perform(*args)
   end
 end
@@ -26,6 +35,15 @@ class RetryDefaultsJob
   end
 end
 
+class SleepDelay1SecondJob < RetryDefaultsJob
+  @queue = :testing
+  @sleep_after_requeue = 1
+
+  def self.perform(*args)
+    raise if retry_attempt == 0
+  end
+end
+
 class InheritTestJob < RetryDefaultsJob
 end
 
@@ -54,6 +72,11 @@ class RetryWithModifiedArgsJob < RetryDefaultsJob
 end
 
 class NeverGiveUpJob < RetryDefaultsJob
+  @queue = :testing
+  @retry_limit = -1
+end
+
+class NeverRetryJob < RetryDefaultsJob
   @queue = :testing
   @retry_limit = 0
 end
@@ -67,6 +90,12 @@ class LimitThreeJob < RetryDefaultsJob
   end
 end
 
+class LimitThreeJobDelay1Hour < LimitThreeJob
+  @queue = :testing
+  @retry_limit = 3
+  @retry_delay = 3600
+end
+
 class FailFiveTimesJob < RetryDefaultsJob
   @queue = :testing
   @retry_limit = 6
@@ -204,32 +233,6 @@ class InheritOrderingJobExtendFirst
   end
 end
 
-# This job switches to successful after
-# n +tries+.
-class SwitchToSuccessJob < GoodJob
-  @queue = :testing
-  @max_retries = 3
-
-  class << self
-    attr_accessor :successful_after
-    attr_accessor :tries
-
-    def reset_defaults
-      self.tries = 0
-      self.successful_after = 2
-    end
-  end
-
-  reset_defaults
-
-  def self.perform(*args)
-    if self.tries < self.successful_after
-      self.tries += 1
-      raise "error"
-    end
-  end
-end
-
 class InheritOrderingJobExtendLast
   class << self
     attr_accessor :test_value
@@ -247,5 +250,22 @@ class InheritOrderingJobExtendLast
   end
 end
 
+
 class InheritOrderingJobExtendFirstSubclass < InheritOrderingJobExtendFirst; end
 class InheritOrderingJobExtendLastSubclass < InheritOrderingJobExtendLast; end
+
+class CustomIdentifierFailingJob
+  extend Resque::Plugins::Retry
+
+  @queue = :testing
+  @retry_limit = 2
+  @retry_delay = 0
+
+  def self.identifier(*args)
+    args.first.to_s
+  end
+
+  def self.perform(*args)
+    raise 'failed'
+  end
+end

metadata

@@ -1,123 +1,115 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: resque-retry
-version: !ruby/object:Gem::Version 
-  hash: 27
-  prerelease: false
-  segments: 
-  - 0
-  - 1
-  - 0
-  version: 0.1.0
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Luke Antins
 - Ryan Carver
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-08-29 00:00:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: resque
+date: 2011-11-23 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2165851780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  version_requirements: *2165851780
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: &2165851020 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 55
-        segments: 
-        - 1
-        - 8
-        - 0
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.8.0
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: resque-scheduler
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *2165851020
+- !ruby/object:Gem::Dependency
+  name: resque-scheduler
+  requirement: &2165835400 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 55
-        segments: 
-        - 1
-        - 8
-        - 0
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.8.0
   type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: test-unit
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *2165835400
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &2165834800 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: turn
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: *2165834800
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: &2165834000 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: *2165834000
+- !ruby/object:Gem::Dependency
   name: yard
+  requirement: &2165833040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  version_requirements: *2165833040
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &2165832180 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id005
-- !ruby/object:Gem::Dependency 
-  name: simplecov-html
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  version_requirements: *2165832180
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &2165831320 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 19
-        segments: 
-        - 0
-        - 3
-        - 0
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.3.0
   type: :development
-  version_requirements: *id006
-description: "  resque-retry provides retry, delay and exponential backoff support for\n  resque jobs.\n\n  Features:\n\n  * Redis backed retry count/limit.\n  * Retry on all or specific exceptions.\n  * Exponential backoff (varying the delay between retrys).\n  * Multiple failure backend with retry suppression & resque-web tab.\n  * Small & Extendable - plenty of places to override retry logic/settings.\n"
+  prerelease: false
+  version_requirements: *2165831320
+description: ! "  resque-retry provides retry, delay and exponential backoff support
+  for\n  resque jobs.\n\n  Features:\n\n  * Redis backed retry count/limit.\n  * Retry
+  on all or specific exceptions.\n  * Exponential backoff (varying the delay between
+  retrys).\n  * Multiple failure backend with retry suppression & resque-web tab.\n
+  \ * Small & Extendable - plenty of places to override retry logic/settings.\n"
 email: luke@lividpenguin.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - LICENSE
 - Rakefile
 - README.md
@@ -129,6 +121,7 @@ files:
 - test/retry_criteria_test.rb
 - test/retry_inheriting_checks_test.rb
 - test/retry_test.rb
+- test/server_test.rb
 - test/test_helper.rb
 - test/test_jobs.rb
 - lib/resque/failure/multiple_with_retry_suppression.rb
@@ -138,39 +131,30 @@ files:
 - lib/resque-retry/server/views/retry_timestamp.erb
 - lib/resque-retry/server.rb
 - lib/resque-retry.rb
-has_rdoc: false
 homepage: http://github.com/lantins/resque-retry
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: A resque plugin; provides retry, delay and exponential backoff support for resque jobs.
+summary: A resque plugin; provides retry, delay and exponential backoff support for
+  resque jobs.
 test_files: []
-
+has_rdoc: false