sidekiq-superworker 0.1.9 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 014ddac6c1e85e35f8250f215693e183698440bf
-  data.tar.gz: 573940cf6cdc6b055f870124dbb3d4afc9cc3f0b
+  metadata.gz: 53beee36ab3ca54954950636adfc11d3e5d6c8e5
+  data.tar.gz: 168d1b43b60f7085b1cb5f3185208d88c94effbd
 SHA512:
-  metadata.gz: 6b77c4f34765af555b1efb6a6b7d8c089c47a4a27a6642294c9173cd4804a742495199162ce7ca829a595fd9b3e4082496e8235f77e28c5ff1ee8062e76ea2f5
-  data.tar.gz: 3433ab2858b6cd155beea4ab729fae4870b985563b99b71cbd915a41e4aa504465d39937e1a4c8c0c204bde424c8d63d3fc3fe0ae55d55e247322902209fbd34
+  metadata.gz: f9606cbc54a87383c448ab89ba308df8ca4713caa92920a8d9cb4365c7ede28447ba811e5eced133310b8e32b613ff5f3a56afc51e10cc284141ae2f08cdf218
+  data.tar.gz: f2b6beafee29aec0ed97ecf22f334697ea7c235d2886cbd3c95f668e2a8e009303b617a204082b64777fd171ee668700ac32b3cb44fc8cc16518d1466c5d6ffb

data/README.md

@@ -1,20 +1,20 @@
 Sidekiq Superworker
 ===================
-Chain together Sidekiq workers in parallel and/or serial configurations
+Define dependency graphs of Sidekiq jobs
 
 Overview
 --------
 
-Sidekiq Superworker lets you create superworkers, which are simple or complex chains of Sidekiq workers.
+Sidekiq Superworker lets you create superworkers, which are simple or complex graphs of Sidekiq workers.
 
-For example, you can define complex chains of workers, and even use parallel blocks:
+For example, you can define complex graphs of workers and use both serial and parallel worker configurations:
 
 [![](https://raw.github.com/socialpandas/sidekiq-superworker/master/doc/diagram-complex.png)](https://raw.github.com/socialpandas/sidekiq-superworker/master/doc/diagram-complex.png)
 
 *(Worker10 will run after Worker5, Worker7, Worker8, and Worker9 have all completed.)*
 
 ```ruby
-Superworker.create(:MySuperworker, :user_id, :comment_id) do
+Superworker.define(:MySuperworker, :user_id, :comment_id) do
   Worker1 :user_id
   Worker2 :user_id do
     parallel do
@@ -41,12 +41,12 @@ And you can run it like any other worker:
 MySuperworker.perform_async(23, 852)
 ```
 
-You can also define simple serial chains of workers:
+You can also define simple serial sequences of workers:
 
 [![](https://raw.github.com/socialpandas/sidekiq-superworker/master/doc/diagram-simple.png)](https://raw.github.com/socialpandas/sidekiq-superworker/master/doc/diagram-simple.png)
 
 ```ruby
-Superworker.create(:MySuperworker, :user_id, :comment_id) do
+Superworker.define(:MySuperworker, :user_id, :comment_id) do
   Worker1 :user_id, :comment_id
   Worker2 :comment_id
   Worker3 :user_id
@@ -60,11 +60,6 @@ Include it in your Gemfile:
 
     gem 'sidekiq-superworker'
 
-Install and run the migration:
-
-    rails g sidekiq:superworker:install
-    rake db:migrate
-
 Usage
 -----
 
@@ -73,12 +68,12 @@ First, define a superworker in a file that's included during the initialization
 ```ruby
 # config/initializers/superworkers.rb
 
-Superworker.create(:MySuperworker, :user_id, :comment_id) do
+Superworker.define(:MySuperworker, :user_id, :comment_id) do
   Worker1 :user_id, :comment_id
   Worker2 :comment_id
 end
 
-Superworker.create(:MyOtherSuperworker, :comment_id) do
+Superworker.define(:MyOtherSuperworker, :comment_id) do
   Worker2 :comment_id
   Worker3 :comment_id
 end
@@ -95,7 +90,7 @@ MySuperworker.perform_async(23, 852)
 You can define any number of arguments for the superworker and pass them to different subworkers as you see fit:
 
 ```ruby
-Superworker.create(:MySuperworker, :user_id, :comment_id) do
+Superworker.define(:MySuperworker, :user_id, :comment_id) do
   Worker1 :user_id, :comment_id
   Worker2 :comment_id
   Worker3 :user_id
@@ -105,7 +100,7 @@ end
 If you want to set any static arguments for the subworkers, you can do that by using any values that are not symbols (e.g. strings, integers, etc):
 
 ```ruby
-Superworker.create(:MySuperworker, :user_id, :comment_id) do
+Superworker.define(:MySuperworker, :user_id, :comment_id) do
   Worker1 100, :user_id, :comment_id
   Worker2 'all'
 end
@@ -114,7 +109,7 @@ end
 If a subworker doesn't take any arguments, you'll need to include parentheses after it:
 
 ```ruby
-Superworker.create(:MySuperworker, :user_id, :comment_id) do
+Superworker.define(:MySuperworker, :user_id, :comment_id) do
   Worker1 :user_id, :comment_id
   Worker2()
 end
@@ -125,20 +120,20 @@ end
 To refer to a namespaced worker (e.g. `MyModule::Worker1`), replace the two colons with two underscores:
 
 ```ruby
-Superworker.create(:MySuperworker, :user_id, :comment_id) do
+Superworker.define(:MySuperworker, :user_id, :comment_id) do
   MyModule__Worker1 :user_id, :comment_id
 end
 ```
 
 ### Options
 
-#### Insert Method
+#### Delete subjobs after their superjob completes
 
-When a superjob is queued, records for all of its subjobs are created. By default, each subjob record will be created using a separate insert query. If you're creating superjobs with large numbers of subjobs and want to improve performance, you can create these records using a multiple insert query instead. To this, set `:insert_method` to `:multiple`:
+When a superjob is queued, records for all of its subjobs are created. By default these records are deleted when the superjob finished. This can be changed by setting the following option to false:
 
 ```ruby
 # config/initializers/superworker.rb
-Sidekiq::Superworker.options[:insert_method] = :multiple
+Sidekiq::Superworker.options[:delete_subjobs_after_superjob_completes] = false
 ```
 
 ### Logging
@@ -154,14 +149,14 @@ Sidekiq::Superworker::Logging.logger = logger
 
 ### Monitoring
 
-Using [sidekiq_monitor](https://github.com/socialpandas/sidekiq_monitor) with Sidekiq Superworker is strongly encouraged, as it lets you easily monitor when a superjob is running, when it has finished, whether it has encountered errors, and the status of all of its subjobs.
+Using [sidekiq_monitor](https://github.com/socialpandas/sidekiq_monitor) with Sidekiq Superworker is encouraged, as it lets you easily monitor when a superjob is running, when it has finished, whether it has encountered errors, and the status of all of its subjobs.
 
 ### Batch Jobs
 
 By using a `batch` block, you can create batches of subjobs that are all associated with the superjob. The following will run Worker1 and Worker2 in serial for every user ID in the array passed to perform_async.
 
 ```ruby
-Superworker.create(:MyBatchSuperworker, :user_ids) do
+Superworker.define(:MyBatchSuperworker, :user_ids) do
   batch user_ids: :user_id do
     Worker1 :user_id
     Worker2 :user_id
@@ -174,7 +169,7 @@ MyBatchSuperworker.perform_async([30, 31, 32, 33, 34, 35])
 You can also use multiple arguments:
 
 ```ruby
-Superworker.create(:MyBatchSuperworker, :user_ids, :comment_ids) do
+Superworker.define(:MyBatchSuperworker, :user_ids, :comment_ids) do
   batch user_ids: :user_id, comment_ids: :comment_id do
     Worker1 :user_id, :comment_id
     Worker2 :user_id
@@ -215,6 +210,28 @@ If a subjob encounters an exception, the subjobs that depend on it won't run, bu
 
 If sidekiq_monitor is being used, the exception will be bubbled up to the superjob, which lets you easily see when your superjobs have failed.
 
+Upgrading to 1.x
+----------------
+
+If you were previously using Sidekiq Superworker 0.x and are upgrading to 1.x, there are some changes to be aware of:
+
+### Redis replaced ActiveRecord
+
+ActiveRecord was used as the datastore in 0.x due to application-specific requirements, but Redis is a far better choice for many reasons, especially given that Sidekiq uses Redis. When upgrading to 1.x, you'll need to let all of your superjobs complete, then upgrade to 1.x, then resume running superjobs. You can drop the 'sidekiq_superworker_subjobs' table, if you like.
+
+### Superworker.define replaced Superworker.create
+
+The name of the `Superworker.create` method caused confusion, as some users would call it multiple times. Since it defines a class, it's been renamed to `Superworker.define`. You'll need to replace it accordingly.
+
+Testing
+-------
+
+Sidekiq Superworker is tested against multiple sets of gem dependencies (currently: no gems, Rails 3, and Rails 4), so please run the tests with [Appraisal](https://github.com/thoughtbot/appraisal) before submitting a PR. Thanks!
+
+```bash
+appraisal rspec
+```
+
 License
 -------
 

data/Rakefile

@@ -2,11 +2,6 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
 
-task :default => :test
+require 'rspec/core/rake_task'
 
-Rake::TestTask.new do |t|
-  t.libs << "lib"
-  t.libs << "test"
-  t.test_files = FileList["test/**/*_test.rb"]
-  t.verbose = true
-end
+RSpec::Core::RakeTask.new('spec')

data/lib/sidekiq-superworker.rb

@@ -1 +1,3 @@
-require 'sidekiq/superworker'
+require 'active_model'
+require 'active_support/all'
+require 'sidekiq/superworker'

data/lib/sidekiq/superworker.rb

@@ -1,16 +1,15 @@
 require 'sidekiq'
-require 'activerecord-import'
 
 directory = File.dirname(File.absolute_path(__FILE__))
 require "#{directory}/client_ext.rb"
-Dir.glob("#{directory}/superworker/**/*.rb") { |file| require file }
-Dir.glob("#{directory}/../generators/sidekiq/superworker/**/*.rb") { |file| require file }
-Dir.glob("#{directory}/../../app/models/sidekiq/superworker/*.rb") { |file| require file }
+Dir.glob("#{directory}/superworker/*.rb") { |file| require file }
+Dir.glob("#{directory}/superworker/server/*.rb") { |file| require file }
 
 module Sidekiq
   module Superworker
     DEFAULTS = {
-      insert_method: :single
+      delete_subjobs_after_superjob_completes: true,
+      subjob_redis_prefix: 'subjob'
     }
 
     def self.options
@@ -29,9 +28,6 @@ module Sidekiq
       logger.debug(message)
     end
 
-    def self.table_name_prefix
-      'sidekiq_superworker_'
-    end
   end
 end
 
@@ -44,28 +40,5 @@ end
 Superworker = Sidekiq::Superworker::Worker unless Object.const_defined?('Superworker')
 
 if defined?(Sidekiq::Monitor)
-
-  # Make Cleaner ignore superjobs, as they don't exist in Redis and thus won't be synced with Sidekiq::Monitor::Job
-  Sidekiq::Monitor::Cleaner.add_ignored_queue(Sidekiq::Superworker::SuperjobProcessor.queue_name) if defined?(Sidekiq::Monitor)
-
-  # Add a custom view that shows the subjobs for a superjob
-  custom_views_directory = "#{directory}/../../app/views/sidekiq/superworker/subjobs"
-  Sidekiq::Monitor::CustomViews.add 'Subjobs', custom_views_directory do |job|
-    job.queue == Sidekiq::Superworker::SuperjobProcessor.queue_name.to_s
-  end
-
-  # Add a "superjob:{id}" search filter
-  Sidekiq::Monitor::JobsDatatable.add_search_filter({
-    pattern: /^superjob:([\d]+)$/,
-    filter: lambda do |search_term, records|
-      superjob_id = search_term[/^superjob:([\d]+)$/, 1]
-      superjob = Sidekiq::Monitor::Job.find_by_id(superjob_id)
-      # Return empty set
-      return records.where(id: nil) unless superjob
-      superjob_jid = superjob.jid
-      subjob_jids = Sidekiq::Superworker::Subjob.where(superjob_id: superjob_jid).map(&:jid).compact
-      records.where(jid: subjob_jids + [superjob_jid])
-    end
-  })
-
+  require "#{directory}/superworker/integrations/sidekiq_monitor"
 end

data/lib/sidekiq/superworker/dsl_hash.rb

@@ -91,7 +91,8 @@ module Sidekiq
             subworker_class: 'batch_child',
             arg_keys: iteration_keys,
             arg_values: iteration_args.values,
-            parent_id: batch_id
+            parent_id: batch_id,
+            children_ids: []
           }
           @records[batch_child_id] = batch_child
 
@@ -109,6 +110,7 @@ module Sidekiq
             @records[last_subjob_id][:next_id] = subjob_id if last_subjob_id
             last_subjob_id = subjob_id
             nested_hash_to_records(children, parent_id: subjob_id, scoped_args: iteration_args)
+            batch_child[:children_ids] << subjob_id
           end
 
           children_ids << batch_child_id

data/lib/sidekiq/superworker/integrations/sidekiq_monitor.rb

@@ -0,0 +1,27 @@
+directory = File.dirname(File.absolute_path(__FILE__))
+
+# Make Cleaner ignore superjobs, as they don't exist in Redis and thus won't be synced with Sidekiq::Monitor::Job
+Sidekiq::Monitor::Cleaner.add_ignored_queue(Sidekiq::Superworker::SuperjobProcessor.queue_name) if defined?(Sidekiq::Monitor)
+
+# Add a custom view that shows the subjobs for a superjob
+custom_views_directory = "#{directory}/../../../../app/views/sidekiq/superworker/subjobs"
+Sidekiq::Monitor::CustomViews.add 'Subjobs', custom_views_directory do |job|
+  job.queue == Sidekiq::Superworker::SuperjobProcessor.queue_name.to_s
+end
+
+# Add a "superjob:{id}" search filter
+Sidekiq::Monitor::JobsDatatable.add_search_filter({
+  pattern: /^superjob:([\d]+)$/,
+  filter: lambda do |search_term, records|
+    superjob_id = search_term[/^superjob:([\d]+)$/, 1]
+    superjob = Sidekiq::Monitor::Job.find_by_id(superjob_id)
+    # Return empty set
+    return records.where(id: nil) unless superjob
+    superjob_jid = superjob.jid
+    subjob_jids = Sidekiq::Superworker::Subjob.find_by_superjob_jid(superjob_jid).map(&:jid).compact
+    records.where(jid: subjob_jids + [superjob_jid])
+  end
+})
+
+# If jobs are deleted after a completion
+Sidekiq::Superworker.options[:delete_subjobs_after_superjob_completes] = false

data/lib/sidekiq/superworker/processor.rb

@@ -11,7 +11,7 @@ module Sidekiq
         raise "Job has nil jid: #{item}" if item['jid'].nil?
 
         Superworker.debug "JID ##{item['jid']}: Error thrown"
-        subjob = find_subjob_by_jid(item['jid'])
+        subjob = Subjob.find_by_jid(item['jid'])
         SubjobProcessor.error(subjob, worker, item, exception) if subjob
       end
 
@@ -21,16 +21,9 @@ module Sidekiq
         raise "Job has nil jid: #{item}" if item['jid'].nil?
 
         Superworker.debug "JID ##{item['jid']}: Passing job from Sidekiq to Superworker"
-        subjob = find_subjob_by_jid(item['jid'])
+        subjob = Subjob.find_by_jid(item['jid'])
         SubjobProcessor.complete(subjob) if subjob
       end
-
-      # Note: The job may've been created outside of sidekiq-superworker, so a nil return value
-      # for this method isn't necessarily problematic
-      def find_subjob_by_jid(jid)
-        Superworker.debug "JID ##{jid}: Finding Subjob"
-        Subjob.find_by_jid(jid)
-      end
     end
   end
 end

data/lib/sidekiq/superworker/server/middleware.rb

@@ -7,16 +7,14 @@ module Sidekiq
         end
 
         def call(worker, item, queue)
-          ActiveRecord::Base.connection_pool.with_connection do
-            begin
-              return_value = yield
-            rescue Exception => exception
-              @processor.error(worker, item, queue, exception)
-              raise exception
-            end
-            @processor.complete(item)
-            return_value
+          begin
+            return_value = yield
+          rescue Exception => exception
+            @processor.error(worker, item, queue, exception)
+            raise exception
           end
+          @processor.complete(item)
+          return_value
         end
       end
     end

data/lib/sidekiq/superworker/subjob.rb

@@ -0,0 +1,164 @@
+module Sidekiq
+  module Superworker
+    class Subjob
+      include ActiveModel::Validations
+      include ActiveModel::Naming
+
+      ATTRIBUTES = [:subjob_id, :superjob_id, :parent_id, :children_ids, :next_id, :children_ids,
+        :subworker_class, :superworker_class, :arg_keys, :arg_values, :status, :descendants_are_complete,
+        :meta]
+
+      attr_accessor *ATTRIBUTES
+
+      validates_presence_of :subjob_id, :subworker_class, :superworker_class, :status
+
+      class << self
+        def create(attributes={})
+          if attributes.is_a?(Array)
+            attributes.collect { |attribute| create(attribute) }
+          else
+            object = new(attributes)
+            object.save
+            object
+          end
+        end
+
+        def find_by_jid(jid)
+          hash = Sidekiq.redis do |conn|
+            conn.hgetall("#{redis_prefix}:#{jid}")
+          end
+          return nil if hash.blank?
+          hash.collect do |key, value|
+            hash[key] = ActiveSupport::JSON.decode(value)
+          end
+          new(hash)
+        end
+
+        def find_by_key(key)
+          return nil if key.blank?
+          jid = key.split(':', 2).last
+          find_by_jid(jid)
+        end
+
+        def find_by_superjob_jid(jid)
+          keys = Sidekiq.redis do |conn|
+            conn.keys("#{redis_prefix}:#{jid}:*")
+          end
+          keys.collect { |key| find_by_key(key) }
+        end
+
+        def all
+          keys.collect { |key| find_by_key(key) }
+        end
+
+        def count
+          keys.length
+        end
+
+        def keys
+          Sidekiq.redis do |conn|
+            conn.keys("#{redis_prefix}:*")
+          end
+        end
+
+        def delete_subjobs_for(superjob_id)
+          Sidekiq.redis do |conn|
+            key = self.jid(superjob_id, '*')
+            keys = conn.keys("#{redis_prefix}:#{key}")
+            conn.del(keys) if keys.any?
+          end
+        end
+
+        def transaction(&block)
+          result = nil
+          Sidekiq.redis do |conn|
+            conn.multi do
+              result = yield
+            end
+          end
+          result
+        end
+
+        def jid(superjob_id, subjob_id)
+          "#{superjob_id}:#{subjob_id}"
+        end
+
+        def redis_prefix
+          Superworker.options[:subjob_redis_prefix]
+        end
+      end
+
+      def initialize(params={})
+        if params.present?
+          params.each do |attribute, value|
+            self.public_send("#{attribute}=", value)
+          end
+        end
+      end
+
+      def save
+        return false unless self.valid?
+        Sidekiq.redis do |conn|
+          conn.mapped_hmset(key, to_param)
+        end
+        true
+      end
+
+      def update_attributes(pairs = {})
+        pairs.each_pair { |attribute, value| send("#{attribute}=", value) }
+        self.save
+      end
+
+      def update_attribute(attribute, value)
+        send("#{attribute.to_s}=", value)
+        return false unless self.valid?
+        Sidekiq.redis do |conn|
+          conn.hset(key, attribute.to_s, value.to_json)
+        end
+        true
+      end
+
+      def jid
+        self.class.jid(superjob_id, subjob_id)
+      end
+
+      def key
+        "#{self.class.redis_prefix}:#{jid}"
+      end
+
+      def descendants_are_complete
+        @descendants_are_complete || false
+      end
+
+      def parent
+        self.class.find_by_jid(self.class.jid(superjob_id, parent_id))
+      end
+
+      def children
+        return [] if children_ids.blank?
+        children = children_ids.collect { |id| self.class.find_by_jid(self.class.jid(superjob_id,id)) }
+        children.reject(&:nil?)
+      end
+
+      def next
+        self.class.find_by_jid(self.class.jid(superjob_id,next_id))
+      end
+
+      def ==(other)
+        self.jid == other.jid
+      end
+
+      def to_info
+        "Subjob ##{jid} (#{superworker_class} > #{subworker_class})"
+      end
+
+      def to_param
+        param = {}
+        ATTRIBUTES.each do |attribute|
+          param["#{attribute.to_s}".to_sym] = send(attribute).to_json
+        end
+        param
+      end
+    end
+  end
+end

data/lib/sidekiq/superworker/subjob_processor.rb

@@ -38,9 +38,8 @@ module Sidekiq
               # the job fires off. If the job started first, it could finish before the ActiveRecord update
               # transaction completes, causing a race condition when finding the ActiveRecord record in
               # Processor#complete.
-              jid = SecureRandom.hex(12)
+              jid = subjob.jid
               subjob.update_attributes(
-                jid: jid,
                 status: 'queued'
               )
               enqueue_in_sidekiq(subjob, klass, jid)

data/lib/sidekiq/superworker/superjob_processor.rb

@@ -26,13 +26,15 @@ module Sidekiq
         end
 
         # Enqueue the first root-level subjob
-        first_subjob = subjobs.select{ |subjob| subjob.parent_id.nil? }.first
+        first_subjob = subjobs.find { |subjob| subjob.parent_id.nil? }
         SubjobProcessor.enqueue(first_subjob)
       end
 
       def self.complete(superjob_id)
         Superworker.debug "Superworker ##{superjob_id}: Complete"
 
+        Subjob.delete_subjobs_for(superjob_id) if Superworker.options[:delete_subjobs_after_superjob_completes]
+        
         # Set the superjob Sidekiq::Monitor::Job as being complete
         if defined?(Sidekiq::Monitor)
           job = Sidekiq::Monitor::Job.where(queue: queue_name, jid: superjob_id).first

data/lib/sidekiq/superworker/version.rb

@@ -1,5 +1,5 @@
 module Sidekiq
   module Superworker
-    VERSION = '0.1.9'
+    VERSION = '1.0.0'
   end
 end

data/lib/sidekiq/superworker/worker.rb

@@ -1,15 +1,19 @@
 module Sidekiq
   module Superworker
     class Worker
-      def self.create(*args, &block)
+      def self.define(*args, &block)
         class_name = args.shift.to_sym
         nested_hash = DSLParser.new.parse(block)
-        create_class(class_name, args, nested_hash)
+        define_class(class_name, args, nested_hash)
+      end
+
+      def self.create(*args, &block)
+        raise NoMethodError.new("Superworker.create has been replaced by Superworker.define.\nPlease see 'Upgrading to 1.x' at https://github.com/socialpandas/sidekiq-superworker.\nSuperworker.create called at #{caller[0]}")
       end
 
       protected
 
-      def self.create_class(class_name, arg_keys, nested_hash)
+      def self.define_class(class_name, arg_keys, nested_hash)
         klass = Class.new(Sidekiq::Superworker::WorkerClass) do
           @class_name = class_name
           @arg_keys = arg_keys

data/lib/sidekiq/superworker/worker_class.rb

@@ -12,6 +12,7 @@ module Sidekiq
           options = initialize_superjob(arg_values)
           subjobs = create_subjobs(arg_values, options)
           SuperjobProcessor.create(@superjob_id, @class_name, arg_values, subjobs, options)
+          @superjob_id
         end
 
         protected
@@ -48,19 +49,8 @@ module Sidekiq
             end
             record
           end
-
-          insert_subjobs(records)
-        end
-
-        def insert_subjobs(records)
-          if Sidekiq::Superworker.options[:insert_method] == :multiple
-            subjobs = records.collect { |record| Sidekiq::Superworker::Subjob.new(record) }
-            Sidekiq::Superworker::Subjob.import(subjobs)
-            Sidekiq::Superworker::Subjob.where(superjob_id: @superjob_id).order(:subjob_id)
-          else
-            Sidekiq::Superworker::Subjob.transaction do
-              Sidekiq::Superworker::Subjob.create(records)
-            end
+          Sidekiq::Superworker::Subjob.transaction do
+            Sidekiq::Superworker::Subjob.create(records)
           end
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-superworker
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 1.0.0
 platform: ruby
 authors:
 - Tom Benner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-03 00:00:00.000000000 Z
+date: 2014-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -25,35 +25,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 2.1.0
 - !ruby/object:Gem::Dependency
-  name: activerecord-import
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
         version: '3.2'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
         version: '3.2'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -67,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec-rails
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
@@ -81,7 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.12'
 - !ruby/object:Gem::Dependency
-  name: database_cleaner
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -94,7 +94,7 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Chain together Sidekiq workers in parallel and/or serial configurations
+description: Define dependency graphs of Sidekiq jobs
 email:
 - tombenner@gmail.com
 executables: []
@@ -104,19 +104,17 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
-- app/models/sidekiq/superworker/subjob.rb
-- app/views/sidekiq/superworker/subjobs.slim
-- lib/generators/sidekiq/superworker/install/install_generator.rb
-- lib/generators/sidekiq/superworker/install/templates/create_sidekiq_superworker_subjobs.rb
 - lib/sidekiq-superworker.rb
 - lib/sidekiq/client_ext.rb
 - lib/sidekiq/superworker.rb
 - lib/sidekiq/superworker/dsl_evaluator.rb
 - lib/sidekiq/superworker/dsl_hash.rb
 - lib/sidekiq/superworker/dsl_parser.rb
+- lib/sidekiq/superworker/integrations/sidekiq_monitor.rb
 - lib/sidekiq/superworker/logging.rb
 - lib/sidekiq/superworker/processor.rb
 - lib/sidekiq/superworker/server/middleware.rb
+- lib/sidekiq/superworker/subjob.rb
 - lib/sidekiq/superworker/subjob_processor.rb
 - lib/sidekiq/superworker/superjob_processor.rb
 - lib/sidekiq/superworker/version.rb
@@ -145,6 +143,6 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Chain together Sidekiq workers in parallel and/or serial configurations
+summary: Define dependency graphs of Sidekiq jobs
 test_files: []
 has_rdoc: 

data/app/models/sidekiq/superworker/subjob.rb

@@ -1,37 +0,0 @@
-module Sidekiq
-  module Superworker
-    class Subjob < ActiveRecord::Base
-      attr_accessible :jid, :subjob_id, :superjob_id, :parent_id, :children_ids, :next_id,
-        :subworker_class, :superworker_class, :arg_keys, :arg_values, :status, :descendants_are_complete,
-        :meta if ActiveRecord::VERSION::MAJOR < 4 || ActiveRecord.constants.include?(:MassAssignmentSecurity)
-
-      serialize :arg_keys
-      serialize :arg_values
-      serialize :children_ids
-      serialize :meta
-
-      validates_presence_of :subjob_id, :subworker_class, :superworker_class, :status
-
-      def relatives
-        self.class.where(superjob_id: superjob_id)
-      end
-
-      def parent
-        return nil if parent_id.nil?
-        relatives.where(subjob_id: parent_id).first
-      end
-
-      def children
-        relatives.where(parent_id: subjob_id).order(:subjob_id)
-      end
-
-      def next
-        relatives.where(subjob_id: next_id).first
-      end
-
-      def to_info
-        "Subjob ##{id} (#{superworker_class} > #{subworker_class})"
-      end
-    end
-  end
-end

data/app/views/sidekiq/superworker/subjobs.slim

@@ -1,16 +0,0 @@
-- subjobs = Sidekiq::Superworker::Subjob.where(superjob_id: job.jid).where('subworker_class != ?', 'batch').order('subjob_id')
-
-table.table.table-condensed.table-striped.table-hover
-  tr
-    th ID
-    th Class
-    th Args
-    th Status
-    th JID
-  - subjobs.each do |subjob|
-    tr
-      td = subjob.id
-      td = subjob.subworker_class
-      td = subjob.arg_values
-      td = subjob.status
-      td = subjob.jid

data/lib/generators/sidekiq/superworker/install/install_generator.rb

@@ -1,27 +0,0 @@
-require 'rails/generators'
-require 'rails/generators/base'
-
-module Sidekiq
-  module Superworker
-    module Generators
-      class InstallGenerator < ::Rails::Generators::Base
-        include ::Rails::Generators::Migration
-        source_root File.expand_path('../templates', __FILE__)
-        desc "Install the migrations"
-
-        def self.next_migration_number(path)
-          unless @prev_migration_nr
-            @prev_migration_nr = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
-          else
-            @prev_migration_nr += 1
-          end
-          @prev_migration_nr.to_s
-        end
-
-        def install_migrations
-          migration_template "create_sidekiq_superworker_subjobs.rb", "db/migrate/create_sidekiq_superworker_subjobs.rb"
-        end
-      end 
-    end
-  end
-end

data/lib/generators/sidekiq/superworker/install/templates/create_sidekiq_superworker_subjobs.rb

@@ -1,26 +0,0 @@
-class CreateSidekiqSuperworkerSubjobs < ActiveRecord::Migration
-  def change
-    create_table :sidekiq_superworker_subjobs do |t|
-      t.string :jid
-      t.string :superjob_id, null: false
-      t.integer :subjob_id, null: false
-      t.integer :parent_id
-      t.text :children_ids
-      t.integer :next_id
-      t.string :superworker_class, null: false
-      t.string :subworker_class, null: false
-      t.text :arg_keys
-      t.text :arg_values
-      t.string :status, null: false
-      t.boolean :descendants_are_complete, default: false
-      t.text :meta
-      
-      t.timestamps
-    end
-
-    add_index :sidekiq_superworker_subjobs, :jid
-    add_index :sidekiq_superworker_subjobs, :subjob_id
-    add_index :sidekiq_superworker_subjobs, [:superjob_id, :subjob_id]
-    add_index :sidekiq_superworker_subjobs, [:superjob_id, :parent_id]
-  end
-end