resque-batched-job 1.5.0 → 1.7.0

data/lib/resque/plugins/batched_job/version.rb

@@ -1,7 +1,7 @@
 module Resque
   module Plugins
     module BatchedJob
-      VERSION = '1.5.0'
+      VERSION = '1.7.0'
     end
   end
 end

data/lib/resque/plugins/batched_job.rb

@@ -46,6 +46,7 @@ module Resque
       # @param id (see Resque::Plugins::BatchedJob#after_enqueue_batch)
       def after_perform_batch(id, *args)
         if remove_batched_job(id, *args) == 0
+          
           after_batch_hooks = Resque::Plugin.after_batch_hooks(self)
           after_batch_hooks.each do |hook|
             send(hook, id, *args)
@@ -96,6 +97,31 @@ module Resque
         after_perform_batch(id, *args)
       end
 
+      # Build a collection of Resque::Job objects that represent each job in a 
+      # batch of the same class.
+      #
+      # @param id (see Resque::Plugins::BatchedJob#remove_batched_job)
+      # @returns [Array] Collection of Resque::Job objects
+      def batched_jobs(id)
+        bid = batch(id)
+        regexp = /\A\{\"class\":\"#{self.name}\",\"args\":\[/
+        redis.lrange(bid, 0, redis.llen(bid)-1).grep(regexp).map do |string|
+          payload = decode(string)
+          payload['args'].unshift(id)
+          Resque::Job.new(@queue, payload)
+        end
+      end
+
+      # Collect and recreate all jobs for the given batch.
+      #
+      # @param id (see Resque::Plugins::BatchedJob#remove_batched_job)
+      # @returns [Integer] Number of jobs recreated.
+      def recreate_batched_jobs(id)
+        batched_jobs(id).each do |job|
+          job.recreate
+        end.size
+      end
+
       private
 
         # Lock a batch key before executing Redis commands.  This will ensure

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque-batched-job
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-21 00:00:00.000000000 Z
+date: 2012-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: resque
-  requirement: &70272544091880 !ruby/object:Gem::Requirement
+  requirement: &70188523453360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 1.10.0
   type: :runtime
   prerelease: false
-  version_requirements: *70272544091880
+  version_requirements: *70188523453360
 - !ruby/object:Gem::Dependency
   name: turn
-  requirement: &70272544091120 !ruby/object:Gem::Requirement
+  requirement: &70188523451760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,18 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70272544091120
+  version_requirements: *70188523451760
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &70188523449820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70188523449820
 description: ! "  Resque plugin for batching jobs. When a batch/group of jobs are
   complete, \nadditional work can be performed usings batch hooks.\n"
 email: dan@dj-agiledev.com
@@ -41,16 +52,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
-- Rakefile
-- README.md
+- lib/resque-batched-job.rb
 - lib/resque/batched_job.rb
-- lib/resque/plugins/batched_job/support.rb
-- lib/resque/plugins/batched_job/tasks.rb
-- lib/resque/plugins/batched_job/version.rb
 - lib/resque/plugins/batched_job.rb
-- lib/resque-batched-job.rb
-- test/test_batched_job.rb
-- test/test_helper.rb
+- lib/resque/plugins/batched_job/version.rb
 homepage: https://github.com/drfeelngood/resque-batched-job
 licenses: []
 post_install_message: 
@@ -71,11 +76,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.16
 signing_key: 
 specification_version: 3
 summary: Resque plugin
-test_files:
-- test/test_batched_job.rb
-- test/test_helper.rb
+test_files: []
 has_rdoc: 

data/README.md

@@ -1,33 +0,0 @@
-# Resque Batched Job [![Build Status](https://secure.travis-ci.org/drfeelngood/resque-batched-job.png)](http://travis-ci.org/drfeelngood/resque-batched-job)
-
-A [Resque](http://github.com/defunkt/resque) plugin. Requires Resque >= 1.10.0
-
-This plugin adds the ability to batch jobs and run additional hooks after the 
-last job in a batch is performed.  Using the '*after_enqueue*' hook, the job
-is encoded and stored in a Redis List identified by the batch id provided.  By default, 
-the batch keys look like '*batch:#{id}*'.  After each job is performed, it's removed
-from the batch list.  If the last job performed happens to be the last in the list, 
-additional hooks are executed.  These hooks are prefixed with '*after_batch*'.
-
-## Installation
-
-    $ gem install resque-batched-job
-
-## Example
-
-```ruby
-require 'resque/batched_job'
-
-module Job
-  extend Resque::Plugins::BatchedJob
-
-  def self.perform(bid, *args)
-    prime(bid, args)
-  end
-
-  def self.after_batch_heavy_lifting(bid, *args)
-    heavy_lifting(bid)
-  end
-
-end
-```

data/Rakefile

@@ -1,52 +0,0 @@
-require 'rubygems'
-require 'rake'
-require 'rake/testtask'
-
-require File.dirname(__FILE__) + '/lib/resque/plugins/batched_job/version'
-
-task :default => :test
-
-Rake::TestTask.new do |task|
-  task.pattern = 'test/test_*.rb'
-  task.verbose = true
-end
-
-begin
-  require 'yard'
-  YARD::Rake::YardocTask.new do |t|
-    t.files   = ['lib/**/*.rb', '-', 'README.md']
-  end
-rescue LoadError
-end
-
-desc "Publish RubyGem and source."
-task :publish => [:build, :tag] do
-  sh "git push origin v#{Resque::Plugins::BatchedJob::VERSION}"
-  sh "git push origin master"
-  sh "gem push resque-batched-job-#{Resque::Plugins::BatchedJob::VERSION}.gem"
-end
-
-desc "Tag project with current version."
-task :tag do
-  sh "git tag v#{Resque::Plugins::BatchedJob::VERSION}"
-end
-
-desc "Build resque-batched-job RubyGem."
-task :build do
-  sh "gem build resque-batched-job.gemspec"
-end
-
-desc "Install current resque-batched-job RubyGem."
-task :install => :build do
-  sh "gem install --local resque-batched-job-#{Resque::Plugins::BatchedJob::VERSION}.gem"
-end
-
-desc "View changelog"
-task :changelog do
-  tags = `git tag`.split("\n").reverse
-
-  tags.each_slice(2) do |tags|
-    puts "========== #{tags[1]}..#{tags[0]} =========="
-    `git log --pretty=format:'%h : %s' --graph #{tags[1]}..#{tags[0]}`
-  end
-end

data/lib/resque/plugins/batched_job/support.rb

@@ -1,72 +0,0 @@
-module Resque
-  module Plugins
-    module BatchedJobSupport
-
-      # Checks the size of the batched job list and returns true if the list is
-       # empty or if the key does not exist.
-       #
-       # @param batch_id (see Resque::Plugins::BatchedJob#batch)
-       def batch_complete?(batch_id)
-         mutex(batch_id) do |bid| 
-           redis.llen(bid) == 0
-         end
-       end
-
-       # Check to see if the Redis key exists.
-       #
-       # @param batch_id (see Resque::Plugins::BatchedJob#batch)
-       def batch_exist?(batch_id)
-         mutex(batch_id) do |bid| 
-           redis.exists(bid)
-         end
-       end
-
-      private
-
-      # Lock a batch key before executing Redis commands.  This will ensure
-      # no race conditions occur when modifying batch information.  Here is
-      # an example of how this works.  See http://redis.io/commands/setnx for
-      # more information. (fixes #4) (closes #5)
-      # 
-      # * Job2 sends SETNX batch:123:lock in order to aquire a lock.
-      # * Job1 still has the key locked, so Job2 continues into the loop.
-      # * Job2 sends GET to aquire the lock timestamp.
-      # * If the timestamp does not exist (Job1 released the lock), Job2 
-      #   attemps to start from the beginning again.
-      # * If the timestamp exists and has not expired, Job2 sleeps for a 
-      #   moment and then retries from the start.
-      # * If the timestamp exists and has expired, Job2 sends GETSET to aquire
-      #   a lock.  This returns the previous value of the lock.
-      # * If the previous timestamp has not expired, another process was faster
-      #   and aquired the lock.  This means Job2 has to start from the beginnig.
-      # * If the previous timestamp is still expired the lock has been set and
-      #   processing can continue safely
-      #
-      # @param id (see Resque::Plugins::BatchedJob#batch)
-      # @yield [bid] Yields the current batch id.
-      # @yieldparam [String] The current batch id.
-      def mutex(id, &block)
-        is_expired = lambda do |locked_at|
-          locked_at.to_f < Time.now.to_f
-        end
-        bid   = batch(id)
-        _key_ = "#{bid}:lock"
-
-        until redis.setnx(_key_, Time.now.to_f + 0.5)
-          next unless timestamp = redis.get(_key_)
-
-          unless is_expired.call(timestamp)
-            sleep(0.1)
-            next
-          end
-
-          break unless timestamp = redis.getset(_key_, Time.now.to_f + 0.5)
-          break if is_expired.call(timestamp)
-        end
-        yield(bid)
-      ensure
-        redis.del(_key_)
-      end
-    end
-  end
-end

data/lib/resque/plugins/batched_job/tasks.rb

@@ -1,6 +0,0 @@
-namespace :resque do
-
-
-end
-
-

data/test/test_batched_job.rb

@@ -1,185 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class BatchedJobTest < Test::Unit::TestCase
-
-  def setup
-    $batch_complete = false
-    @batch_id = :foo
-    @batch = "batch:#{@batch_id}"
-  end
-
-  def teardown
-    redis.del(@batch)
-    redis.del("queue:test")
-    redis.del("#{@batch}:lock")
-  end
-
-  def test_list
-    assert_nothing_raised do
-      Resque::Plugin.lint(Resque::Plugins::BatchedJob)
-    end
-  end
-
-  def test_encoding
-    Resque.enqueue(Job, @batch_id, 123)
-    Resque.enqueue(JobWithoutArgs, @batch_id)
-
-    assert_equal("{\"class\":\"Job\",\"args\":[123]}", redis.lindex(@batch, 0))
-    assert_equal("{\"class\":\"JobWithoutArgs\",\"args\":[]}", redis.lindex(@batch, 1))
-  end
-
-  def test_batch_key
-    assert_nothing_raised do
-      Resque.enqueue(Job, @batch_id, 'foobar')
-    end
-    assert_equal(@batch, Job.batch(@batch_id))
-  end
-
-  # Ensure the length of the Redis list matches the number of jobs we enqueue.
-  def test_batch_size
-    assert_nothing_raised do
-      5.times { Resque.enqueue(Job, @batch_id, "arg#{rand(100)}") }
-    end
-    assert_equal(5, redis.llen(@batch))
-  end
-
-  # Make sure the after_batch hook is fired
-  def test_batch_hooks
-    assert_equal(false, Job.batch_exist?(@batch_id))
-
-    assert_nothing_raised do
-      5.times { Resque.enqueue(Job, @batch_id, "arg#{rand(100)}") }
-    end
-
-    assert_equal(false, $batch_complete)
-    assert_equal(false, Job.batch_complete?(@batch_id))
-    assert(Job.batch_exist?(@batch_id))
-
-    assert_nothing_raised do
-      4.times { Resque.reserve(:test).perform }
-    end
-
-    assert_equal(false, $batch_complete)
-    assert_equal(false, Job.batch_complete?(@batch_id))
-    assert(Job.batch_exist?(@batch_id))
-
-    assert_nothing_raised do
-      Resque.reserve(:test).perform
-    end
-
-    assert($batch_complete)
-    assert(Job.batch_complete?(@batch_id))
-    assert_equal(false, Job.batch_exist?(@batch_id))
-  end
-
-  # Test that jobs with identical args behave properly.
-  def test_duplicate_args
-    assert_equal(false, Job.batch_exist?(@batch_id))
-
-    assert_nothing_raised do
-      5.times { Resque.enqueue(JobWithoutArgs, @batch_id) }
-    end
-
-    assert_equal(false, $batch_complete)
-    assert_equal(false, Job.batch_complete?(@batch_id))
-    assert(Job.batch_exist?(@batch_id))
-
-    assert_nothing_raised do
-      2.times { Resque.reserve(:test).perform }
-    end
-
-    assert_equal(false, $batch_complete)
-    assert_equal(false, Job.batch_complete?(@batch_id))
-    assert(Job.batch_exist?(@batch_id))
-
-    assert_nothing_raised do
-      3.times { Resque.reserve(:test).perform }
-    end
-
-    assert($batch_complete)
-    assert(Job.batch_complete?(@batch_id))
-    assert_equal(false, Job.batch_exist?(@batch_id))
-  end
-
-  # Make sure the block is executed and the lock is removed.
-  def test_mutex
-    Job.send(:mutex, @batch_id) do
-      assert(true)
-    end
-    assert_equal(false, redis.exists("#{@batch}:lock"))
-  end
-
-  # Make sure no race conditions occur.
-  def test_locking
-    threads = []
-    x, y = 10, 5
-
-    x.times do
-      threads << Thread.new do
-        y.times do
-          Job.send(:mutex, @batch_id) do
-            redis.incr(@batch)
-          end
-        end
-      end
-    end
-    threads.each { |t| t.join }
-
-    assert_equal(x * y, Integer(redis.get(@batch)))
-  end
-
-  def test_remove_batched_job
-    Resque.enqueue(JobWithoutArgs, @batch_id)
-    Resque.enqueue(JobWithoutArgs, @batch_id)
-    assert_equal(1, JobWithoutArgs.remove_batched_job(@batch_id))
-    assert_equal(0, JobWithoutArgs.remove_batched_job(@batch_id))
-
-    Resque.enqueue(JobWithoutArgs, @batch_id)
-
-    assert_nothing_raised do
-      JobWithoutArgs.remove_batched_job(@batch_id)
-    end
-    assert(Job.batch_complete?(@batch_id))
-    assert_equal(false, Job.batch_exist?(@batch_id))
-    assert_equal(false, $batch_complete)
-
-    Resque.enqueue(JobWithoutArgs, @batch_id)
-
-    assert_nothing_raised do
-      JobWithoutArgs.remove_batched_job!(@batch_id)
-    end
-    assert($batch_complete)
-    assert(Job.batch_complete?(@batch_id))
-    assert_equal(false, Job.batch_exist?(@batch_id))
-  end
-
-  def test_enqueue_batched_job
-    Resque.enqueue_batched_job(JobWithoutArgs, @batch_id)
-    assert(Job.batch_exist?(@batch_id))
-  end
-
-  def test_dequeue
-    assert_nothing_raised do
-      2.times do
-        Resque.enqueue(JobWithoutArgs, @batch_id)
-        Resque.enqueue(Job, @batch_id, "foo")
-      end
-    end
-
-    Resque.dequeue(JobWithoutArgs, @batch_id)
-    assert_equal(3, redis.llen(@batch))
-    Resque.dequeue(Job, @batch_id, "foo")
-    assert_equal(2, redis.llen(@batch))
-    Resque.dequeue(JobWithoutArgs, @batch_id)
-    Resque.dequeue(Job, @batch_id, "foo")
-    assert(Job.batch_complete?(@batch_id))
-    assert_equal(false, Job.batch_exist?(@batch_id))
-  end
-
-  private
-
-    def redis
-      Resque.redis
-    end
-
-end

data/test/test_helper.rb

@@ -1,34 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-require 'thread'
-require 'turn/autorun'
-require 'resque'
-
-$:.unshift(File.expand_path(File.dirname(__FILE__)) + '/../lib')
-require 'resque/batched_job'
-
-class Job
-  extend Resque::Plugins::BatchedJob
-  @queue = :test
-
-  def self.perform(batch_id, arg)
-  end
-
-  def self.after_batch_hook(batch_id, arg)
-    $batch_complete = true
-  end
-
-end
-
-class JobWithoutArgs
-  extend Resque::Plugins::BatchedJob
-  @queue = :test
-
-  def self.perform(id)
-  end
-
-  def self.after_batch_hook(id)
-    $batch_complete = true
-  end
-
-end