resque-batch 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 357f8a6a48d8391a5f5b2f20e98801b757dd564fe06b76d70cd9303f353eee12
+  data.tar.gz: f58932446902c95dc79468fa085bc24c84188e926099a3b1c8403e1aaf4440a1
+SHA512:
+  metadata.gz: d53e9e71b59493a44c1dd5001ff995d0628277a3165b342151e073fba444b24cc458a94f6a05e738cc77a3f14f8debb8c9175b1d69f3d1427bfa7915ee390e5a
+  data.tar.gz: 06c66ac0875d3830c6e37880b57959893819c3be4ae82bf72c715dfdda04f8b229e9b1b5eee36971f943d7f7f3ba5a08a9e8afe32709e34163e8dc7ea946113d

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+# /Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+.byebug_history

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in resque-batch.gemspec
+gemspec
+
+gem 'byebug'

data/Gemfile.lock

@@ -0,0 +1,61 @@
+PATH
+  remote: .
+  specs:
+    resque-batch (0.2.1)
+      resque (~> 1.25)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (9.1.0)
+    diff-lcs (1.3)
+    mono_logger (1.1.0)
+    multi_json (1.12.2)
+    mustermann (1.0.1)
+    rack (2.0.3)
+    rack-protection (2.0.0)
+      rack
+    rake (10.5.0)
+    redis (4.0.1)
+    redis-namespace (1.6.0)
+      redis (>= 3.0.4)
+    resque (1.27.4)
+      mono_logger (~> 1.0)
+      multi_json (~> 1.0)
+      redis-namespace (~> 1.3)
+      sinatra (>= 0.9.2)
+      vegas (~> 0.1.2)
+    rspec (3.6.0)
+      rspec-core (~> 3.6.0)
+      rspec-expectations (~> 3.6.0)
+      rspec-mocks (~> 3.6.0)
+    rspec-core (3.6.0)
+      rspec-support (~> 3.6.0)
+    rspec-expectations (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-mocks (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-support (3.6.0)
+    sinatra (2.0.0)
+      mustermann (~> 1.0)
+      rack (~> 2.0)
+      rack-protection (= 2.0.0)
+      tilt (~> 2.0)
+    tilt (2.0.8)
+    vegas (0.1.11)
+      rack (>= 1.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.15)
+  byebug
+  rake (~> 10.0)
+  resque-batch!
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.16.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Eric Sullivan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,112 @@
+# Resque - Batch
+
+A plugin for Resque that allow for batched jobs. It provides two components: a batch and a wrapper around a normal Resque job. The wrapper handles communicating to the batch through a redis list, providing status updates as the jobs are processed. This allow the main program to call 'perform' on a batch, and wait for results that are processed by multiple resque workers.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'resque-batch', git: 'git@github.com:annkissam/resque-batch.git'
+```
+
+And then execute:
+
+    $ bundle
+
+
+## Usage
+
+### Create a Batch Worker
+
+* include 'Resque::Plugins::Batch::Job'
+* the method is perform_job (not perform)
+* You should return `success, message`
+
+```ruby
+class Archive
+  include Resque::Plugins::Batch::Job
+
+  def self.perform_job(repo_id, branch = 'master')
+    repo = Repository.find(repo_id)
+    repo.create_archive(branch)
+
+    return true, nil
+  end
+end
+```
+
+### Create a Batch (and call perform)
+
+```
+batch = Resque::Plugins::Batch.new()
+batch.enqueue(Job, 11)
+batch.enqueue(Job, 12, "test2")
+result = batch.perform
+```
+
+## message_handler
+
+You can process results as they arrive w/ a message_handler:
+
+```
+batch.init_handler do |batch_jobs|
+  puts "Notify client it's starting"
+end
+
+batch.exit_handler do |batch_jobs|
+  puts "You're done!"
+end
+
+batch.job_begin_handler do |batch_jobs, job_id|
+  puts "Job #{job_id} started w/ params #{batch_jobs[job_id].args}"
+end
+
+batch.job_success_handler do |batch_jobs, job_id, data|
+  puts "Job #{job_id} succeeded w/ results #{data}"
+end
+
+result = batch.perform
+```
+
+If you need to send additional notifications there's an 'info' message
+
+```
+class Archive
+  include Resque::Plugins::Batch::Job
+  
+  def self.perform_job(repo_id, branch = 'master')
+    ...
+      @worker_job_info.info!({your: "DATA"})
+    ...
+  end
+end
+
+batch.job_info_handler do |batch_jobs, job_id, data|
+  puts "Job #{job_id} sent info with your: #{data["your"]}"
+end
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+### Testing
+
+This uses Resque which requires Redis. To test:
+
+```
+$brew install redis
+$redis-server /usr/local/etc/redis.conf
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/annkissam/resque-batch.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "resque/batch"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/resque/batch.rb

@@ -0,0 +1 @@
+require 'resque/plugins/batch'

data/lib/resque/plugins/batch.rb

@@ -0,0 +1,146 @@
+require 'resque/plugins/batch'
+
+require "resque"
+require "resque/plugins/batch/version"
+
+require "resque/plugins/batch/batch_job_info"
+require "resque/plugins/batch/job"
+require "resque/plugins/batch/message_handler"
+require "resque/plugins/batch/worker_job_info"
+
+module Resque
+  module Plugins
+    class Batch
+      JOB_HEARTBEAT = 45
+      JOB_HEARTBEAT_TTL = 120
+
+      attr_reader :id,
+                  :message_handler,
+                  :batch_jobs
+
+      def initialize(id: nil, message_handler: Resque::Plugins::Batch::MessageHandler.new)
+        @id = id || get_id
+        @message_handler = message_handler
+        @batch_jobs = []
+      end
+
+      def enqueue(klass, *args)
+        batch_jobs << Resque::Plugins::Batch::BatchJobInfo.new(id, batch_jobs.count, klass, *args)
+      end
+
+      def perform
+        # Make sure the incoming message queue is clear
+        if redis.llen(batch_key) > 0
+          raise "redis list #{batch_key} is not empty"
+        end
+
+        result = redis.multi do
+          batch_jobs.each_with_index do |batch_job, job_id|
+            klass = batch_job.klass
+            queue = Resque.queue_from_class(klass) || batch_queue
+            args = batch_job.args
+            args = [id, job_id] + args
+
+            if Resque.inline
+              begin
+                Resque::Job.create(queue, klass, *args)
+              rescue StandardError => exception
+                # NOTE: We still want to use the normal job messaging
+              end
+            else
+              Resque::Job.create(queue, klass, *args)
+            end
+          end
+        end
+
+        unless Resque.inline
+          unless result.last == job_count
+            raise "not all jobs were queued"
+          end
+        end
+
+        message_handler.send_message(self, :init)
+
+        last_heartbeat_check = Time.now
+        last_activity_check = Time.now
+
+        while(batch_jobs.any?(&:incomplete?)) do
+          msg = redis.lpop(batch_key)
+
+          if msg
+            decoded_msg = Resque.decode(msg)
+
+            if decoded_msg["job_id"]
+              job_id = decoded_msg["job_id"]
+              batch_jobs[job_id].process_job_msg(decoded_msg)
+            end
+
+            last_activity_check = Time.now
+
+            message_handler.send_message(self, :job, decoded_msg)
+          else
+            # Reasons there may be no message
+            # No Workers - check worker count
+            # Workers are processing another batch - register batches, check status
+            # A Job takes a long time - send a heartbeat
+            # A Job dies - send a heartbeat
+
+            if Time.now - last_heartbeat_check > JOB_HEARTBEAT
+              running_jobs = batch_jobs.select(&:running?)
+
+              if running_jobs.any?(&:heartbeat_running?)
+                last_activity_check = Time.now
+              end
+
+              last_heartbeat_check = Time.now
+
+              running_jobs.reject(&:heartbeat_running?).each do |batch_job|
+                decoded_msg = {"job_id" => batch_job.job_id, "msg" => "arrhythmia"}
+                batch_jobs[job_id].process_job_msg(decoded_msg)
+                message_handler.send_message(self, :job, decoded_msg)
+              end
+            end
+
+            idle_duration = Time.now - last_activity_check
+            message_handler.send_message(self, :idle, {duration: idle_duration})
+
+            sleep(1)
+          end
+        end
+
+        message_handler.send_message(self, :exit)
+
+        batch_jobs.all?(&:success?)
+      ensure
+        # Cleanup
+        redis.del(batch_key)
+      end
+
+      def job_count
+        batch_jobs.size
+      end
+
+    private
+
+      def redis
+        Resque.redis
+      end
+
+      def batch_queue
+        "batch"
+      end
+
+      def batch_key
+        "batch:#{id}"
+      end
+
+      # https://redis.io/commands/incr
+      # An atomic counter
+      # Used to identify the response list (batch_key)
+      def get_id
+        redis.incr("batch:id")
+      end
+
+    end
+  end
+end

data/lib/resque/plugins/batch/batch_job_info.rb

@@ -0,0 +1,84 @@
+module Resque
+  module Plugins
+    class Batch
+      # A batch uses this file to store the state of each job.
+      # As messages are received (through redis) they're used to update this data.
+      class BatchJobInfo
+        attr_reader :batch_id,
+                    :job_id,
+                    :klass,
+                    :args
+
+        attr_reader :status,
+                    :result,
+                    :exception,
+                    :duration
+
+        def initialize(batch_id, job_id, klass, *args)
+          @batch_id = batch_id
+          @job_id = job_id
+          @klass = klass
+          @args = args
+          @status = 'pending'
+        end
+
+        def running?
+          status == 'running'
+        end
+
+        def success?
+          status == 'success'
+        end
+
+        def complete?
+          ['success', 'failure', 'exception'].include?(status)
+        end
+
+        def incomplete?
+          !complete? && status != 'unknown'
+        end
+
+        def heartbeat_running?
+          redis.get(heartbeat_key) == "running"
+        end
+
+        # Process the msg sent from WorkerJobInfo
+        def process_job_msg(job_msg)
+          msg = job_msg["msg"]
+          data = job_msg["data"]
+
+          if status == 'pending' && msg == 'begin'
+            @status = 'running'
+            @start_time = Time.now
+          elsif (status == 'running' || status == 'unknown') && (msg == 'success' || msg == 'failure')
+            @status = msg
+            @result = data
+            @duration = Time.now - @start_time
+          elsif (status == 'running' || status == 'unknown') && msg == 'exception'
+            @status = 'exception'
+            @exception = data
+            @duration = Time.now - @start_time
+          elsif msg == "info"
+            # Ignore client defined messages
+            true
+          elsif msg == "arrhythmia"
+            @status = 'unknown'
+            @duration = Time.now - @start_time
+          else
+            raise "State machine Error #{job_msg}"
+          end
+        end
+
+        private
+
+        def redis
+          Resque.redis
+        end
+
+        def heartbeat_key
+          "batch:#{batch_id}:heartbeat:#{job_id}"
+        end
+      end
+    end
+  end
+end

data/lib/resque/plugins/batch/job.rb

@@ -0,0 +1,49 @@
+module Resque
+  module Plugins
+    class Batch
+      module Job
+        def self.included(base)
+          base.extend ClassMethods
+          base.class_eval do
+          end
+        end
+
+        module ClassMethods
+          def perform(batch_id, job_id, *params)
+            heartbeat_thread = nil
+
+            @worker_job_info = Resque::Plugins::Batch::WorkerJobInfo.new(batch_id, job_id)
+
+            @worker_job_info.heartbeat!
+
+            heartbeat_thread = Thread.new do
+              loop do
+                sleep(Resque::Plugins::Batch::JOB_HEARTBEAT)
+                @worker_job_info.heartbeat!
+              end
+            end
+
+            begin
+              @worker_job_info.begin!
+
+              success, data = perform_work(*params)
+
+              if success
+                @worker_job_info.success!(data)
+              else
+                @worker_job_info.failure!(data)
+              end
+            rescue StandardError => exception
+              @worker_job_info.exception!(exception)
+              raise exception
+            end
+          ensure
+            if heartbeat_thread
+              heartbeat_thread.exit
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resque/plugins/batch/message_handler.rb

@@ -0,0 +1,91 @@
+module Resque
+  module Plugins
+    class Batch
+      # NOTE: This is the default Message handler. It takes lambda to handle each message type.
+      # It could be replaced with any other class that responds to send_message(batch, type, msg = {})
+
+      # idle_duration: Set this to a number
+      class MessageHandler
+        attr_accessor :init_handler,
+                      :exit_handler,
+                      :idle_handler,
+                      # :info_handler,
+                      :job_begin_handler,
+                      :job_success_handler,
+                      :job_failure_handler,
+                      :job_exception_handler,
+                      :job_info_handler,
+                      :job_arrhythmia_handler
+
+        def initialize(options = {})
+          @init_handler = options.fetch(:init, ->(_batch){})
+          @exit_handler = options.fetch(:exit, ->(_batch){})
+          @idle_handler = options.fetch(:idle, ->(_batch, msg){})
+
+          # @info_handler = options.fetch(:info, ->(_batch, msg){})
+
+          @job_begin_handler = options.fetch(:job_begin, ->(_batch, _job_id){})
+          @job_success_handler = options.fetch(:job_success, ->(_batch, _job_id, _data){})
+          @job_failure_handler = options.fetch(:job_failure, ->(_batch, _job_id, _data){})
+          @job_exception_handler = options.fetch(:job_exception, ->(_batch, _job_id, _data){})
+          @job_info_handler = options.fetch(:job_info, ->(_batch, _job_id, _data){})
+          @job_arrhythmia_handler = options.fetch(:job_arrhythmia, ->(_batch, _job_id){})
+        end
+
+        def send_message(batch, type, msg = {})
+          case type
+          when :init
+            send_init(batch)
+          when :exit
+            send_exit(batch)
+          when :idle
+            send_idle(batch, msg)
+          when :job
+            send_job(batch, msg)
+          else
+            raise "unknown message type: #{type}"
+          end
+        end
+
+        private
+
+        def send_init(batch)
+          init_handler.call(batch)
+        end
+
+        def send_exit(batch)
+          exit_handler.call(batch)
+        end
+
+        def send_idle(batch, msg)
+          idle_handler.call(batch, msg)
+        end
+
+        # def send_info(batch, msg)
+        # end
+
+        def send_job(batch, msg)
+          job_id = msg["job_id"]
+
+          case msg["msg"]
+          when "begin"
+            job_begin_handler.call(batch, job_id)
+          when "success"
+            job_success_handler.call(batch, job_id, msg["data"])
+          when "failure"
+            job_failure_handler.call(batch, job_id, msg["data"])
+          when "exception"
+            job_exception_handler.call(batch, job_id, msg["data"])
+          when "info"
+            job_info_handler.call(batch, job_id, msg["data"])
+          when "arrhythmia"
+            job_arrhythmia_handler.call(batch, job_id)
+          else
+            raise "unknown msg type: #{msg["msg"]}"
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Resque
+  module Plugins
+    class Batch
+      VERSION = "0.2.1"
+    end
+  end
+end

data/lib/resque/plugins/batch/worker_job_info.rb

@@ -0,0 +1,56 @@
+module Resque
+  module Plugins
+    class Batch
+      # This class will be instantiated in a job and can be used to interact with the batch (by passing messages to a redis list)
+      class WorkerJobInfo
+        attr_reader :batch_id,
+                    :job_id
+
+        def initialize(batch_id, job_id)
+          @batch_id = batch_id
+          @job_id = job_id
+        end
+
+        def begin!
+          redis.rpush(batch_key, Resque.encode(job_id: job_id, msg: 'begin'))
+        end
+
+        def success!(data)
+          redis.rpush(batch_key, Resque.encode(job_id: job_id, msg: 'success', data: data))
+        end
+
+        def failure!(data)
+          redis.rpush(batch_key, Resque.encode(job_id: job_id, msg: 'failure', data: data))
+        end
+
+        def exception!(exception)
+          redis.rpush(batch_key, Resque.encode(job_id: job_id, msg: 'exception', data: {class: exception.class.name, message: exception.message, backtrace: exception.backtrace}))
+        end
+
+        # NOTE: This is the only message that the client should send
+        def info!(data)
+          redis.rpush(batch_key, Resque.encode(job_id: job_id, msg: 'info', data: data))
+        end
+
+        def heartbeat!
+          redis.set(heartbeat_key, "running")
+          redis.expire(heartbeat_key, Resque::Plugins::Batch::JOB_HEARTBEAT_TTL)
+        end
+
+        private
+
+        def redis
+          Resque.redis
+        end
+
+        def batch_key
+          "batch:#{batch_id}"
+        end
+
+        def heartbeat_key
+          "batch:#{batch_id}:heartbeat:#{job_id}"
+        end
+      end
+    end
+  end
+end

data/resque-batch.gemspec

@@ -0,0 +1,38 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "resque/plugins/batch/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "resque-batch"
+  spec.version       = Resque::Plugins::Batch::VERSION
+  spec.authors       = ["Eric Sullivan"]
+  spec.email         = ["eric.sullivan@annkissam.com"]
+
+  spec.summary       = %q{Batch Job functionality for Resque}
+  spec.description   = %q{Adds methods for working with Batch Jobs}
+  spec.homepage      = "https://github.com/annkissam/resque-batch"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against " \
+  #     "public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "resque", "~> 1.25"
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/solano.yml

@@ -0,0 +1,4 @@
+---
+timeout: 1800
+ruby_version: ruby-2.4.1
+bundler_version: 1.16.0

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: resque-batch
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Eric Sullivan
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-08-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.25'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.25'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Adds methods for working with Batch Jobs
+email:
+- eric.sullivan@annkissam.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/resque/batch.rb
+- lib/resque/plugins/batch.rb
+- lib/resque/plugins/batch/batch_job_info.rb
+- lib/resque/plugins/batch/job.rb
+- lib/resque/plugins/batch/message_handler.rb
+- lib/resque/plugins/batch/version.rb
+- lib/resque/plugins/batch/worker_job_info.rb
+- resque-batch.gemspec
+- solano.yml
+homepage: https://github.com/annkissam/resque-batch
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Batch Job functionality for Resque
+test_files: []