resque-delayed 1.0.0

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.rvmrc
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 1.0.0 (2011-09-07)
+
+* initial release.

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) Justin Giancola
+
+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::Delayed
+
+Delayed job queueing for Resque.
+
+Enqueue jobs that will only appear for processing after a specified delay or at a particular time in the future.
+
+## About
+
+Useful for jobs that would be awkward to run in crons. For example:
+
+* expiring stale orders to free up reserved inventory
+* retrying failed webhook deliveries with progressively increasing delays
+
+Also useful for jobs that are typically run in crons. For example:
+
+* sending call-to-action reminder emails a few days after each signup
+* checking whether pending payments have cleared
+
+Fine-grained job scheduling avoids the need for monolithic crons that are often slow, resource intensive and single-process. Instead of needing to stagger crons to avoid overlap or parallelize crons that are too slow, jobs can be spread throughout the entire day and amongst multiple worker processes.
+
+## Usage
+
+Resque::Delayed is very simple. Call `Resque.enqueue_in` or `Resque.enqueue_at` instead of `Resque.enqueue`
+For example:
+
+```ruby
+class User
+  after_create :send_call_to_action_email
+
+  private
+  def send_call_to_action_email
+    Resque.enqueue_in 3.days, CallToActionEmailJob, self.id
+  end
+end
+```
+
+**or**
+
+```ruby
+class RecurringInvoice
+  def generate_invoice
+    # snip...
+
+    Resque.enqueue_at self.next_billing_date, RecurringInvoiceJob, self.id
+  end
+end
+```
+
+**or**
+
+```ruby
+class Webhook
+  MAX_RETRIES = 15
+
+  def deliver
+    unless Webhook.post(payload).success?
+      return if retries == Webhook::MAX_RETRIES
+
+      update_attribute :retries, retries + 1
+
+      Resque.enqueue_in (2**retries).minutes, WebhookDeliveryJob, self.id
+    end
+  end
+end
+```
+
+## Setup
+
+`$ gem install resque-delayed`
+
+or add
+
+`gem 'resque-delayed'`
+
+to your Gemfile and run
+
+ `$ bundle install`
+
+Resque::Delayed piggybacks on your existing Resque setup so it will use whatever Redis instance Resque has been configured to use.
+
+The above will provide `Resque.enqueue_in` and `Resque.enqueue_at` to your application but you will also need to run a Resque::Dealyed worker process. The worker is responsible for harvesting future-queued jobs and pushing them onto the appropriate Resque queues at the right time.
+
+`Resque::Delayed::Worker` is a stripped-down version of `Resque::Worker` so you can use the same configuration options like `INTERVAL`, `PIDFILE`, `LOGGING`, `VERBOSE` and `VVERBOSE`
+
+Like Resque, Resque::Delayed provides a rake task to run workers. Add `require 'resque-delayed/tasks'` to your `Rakefile` and run
+
+    $ cd app_root
+    $ LOGGING=1 INTERVAL=10 rake resque_delayed:work
+
+**NOTE: Resque::Delayed workers only take future-queued jobs and push them onto Resque queues when they need to be run. They do *not* actually process jobs so any setup using Resque::Delayed also needs one or more regular Resque workers.**
+
+## Deployment Considerations
+
+Resque::Delayed workers are very lean as they do not need to load either your application or your Resque job classes. Even so you will probably want to monitor them in production using something like monit, god, or bluepill. Also, because they are not actually performing any of the job processing work it is unlikely you will need to run more than one.<sup>1</sup>
+
+<sup>1</sup> a single Resque::Delayed worker on a laptop with unexciting hardware can push a few thousand jobs per second into Resque while new delayed jobs are simultaneously being added.
+
+## Contributing
+
+1. [fork](http://help.github.com/fork-a-repo/) this repo
+1. create a topic branch (`$ git checkout -b my_branch`)
+1. make your changes along with specs
+1. push to your branch (`$ git push origin my_branch`)
+1. send me a [pull request](http://help.github.com/send-pull-requests/)
+
+## Thanks
+
+Thanks to [defunkt](https://github.com/defunkt) and all Resque contributors. Resque is a pleasure to use and adapts well to new challenges. Also some code in this project, `Resque::Delayed::Worker` in particular, borrows heavily from the Resque implementation.
+
+## Copyright
+
+Copyright (c) Justin Giancola. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,5 @@
+#!/usr/bin/env rake
+
+$:.unshift File.dirname(__FILE__)
+require "bundler/gem_tasks"
+require "lib/resque-delayed/tasks"

data/lib/resque-delayed.rb

@@ -0,0 +1,6 @@
+require 'resque'
+require 'uuidtools'
+
+%w(resque-delayed resque worker).each do |component|
+  require File.join(File.dirname(__FILE__), 'resque-delayed', component)
+end

data/lib/resque-delayed/resque-delayed.rb

@@ -0,0 +1,69 @@
+module Resque
+  module Delayed
+    class << self
+      @queue = "Resque::Delayed:internal"
+
+      def random_uuid
+        UUIDTools::UUID.random_create.to_s.gsub('-', '')
+      end
+
+      def clear
+        Resque.redis.del @queue
+      end
+
+      def count
+        Resque.redis.zcard @queue
+      end
+
+      def create_at(time, *args)
+        klass, *args = args
+        queue = Resque.queue_from_class klass
+        # validate here so that the Resque::Delayed worker doesn't have
+        # to worry about it before enqueueing
+        Resque.validate(klass, queue)
+        Resque.redis.zadd @queue, time.to_i, encode(queue, klass, *args)
+      end
+
+      def create_in(offset, *args)
+        create_at Time.now + offset, *args
+      end
+
+      def encode(queue, klass, *args)
+        "#{random_uuid}|#{Resque.encode([queue, klass.to_s, *args])}"
+      end
+
+      def decode(encoded_job)
+        Resque.decode encoded_job.split('|', 2).last
+      end
+
+      def next
+        next_at Time.now
+      end
+
+      def next_at(time)
+        job = peek_at_serialized(time)
+
+        # it is possible that another process will pull this job out of the
+        # queue before this process has a chance. if that happens, return nil
+        # so that we don't end up duplicating the job.
+        return unless job and Resque.redis.zrem(@queue, job)
+
+        Resque::Delayed.decode job
+      end
+
+      def peek
+        peek_at Time.now
+      end
+
+      def peek_at(time)
+        job = peek_at_serialized(time)
+        job and Resque::Delayed.decode(job)
+      end
+
+      def peek_at_serialized(time)
+        Resque.redis.
+          zrangebyscore(@queue, '-inf', time.to_i, :limit => [0, 1]).first
+      end
+    end
+  end
+end

data/lib/resque-delayed/resque.rb

@@ -0,0 +1,11 @@
+module Resque
+  class << self
+    def enqueue_at(time, *args)
+      Resque::Delayed.create_at time, *args
+    end
+
+    def enqueue_in(offset, *args)
+      Resque::Delayed.create_in offset, *args
+    end
+  end
+end

data/lib/resque-delayed/tasks.rb

@@ -0,0 +1,22 @@
+# require 'resque-delayed/tasks'
+namespace :resque_delayed do
+
+  desc "Start a Resque::Delayed worker"
+  task :work do
+    require 'resque-delayed'
+
+    begin
+      worker = Resque::Delayed::Worker.new
+      worker.verbose = ENV['LOGGING'] || ENV['VERBOSE']
+      worker.very_verbose = ENV['VVERBOSE']
+    end
+
+    if ENV['PIDFILE']
+      File.open(ENV['PIDFILE'], 'w') { |f| f << worker.pid }
+    end
+
+    worker.log "Starting Resque::Delayed worker #{worker}"
+
+    worker.work(ENV['INTERVAL'] || 5) # interval, will block
+  end
+end

data/lib/resque-delayed/version.rb

@@ -0,0 +1,5 @@
+module Resque
+  module Delayed
+    VERSION = "1.0.0"
+  end
+end

data/lib/resque-delayed/worker.rb

@@ -0,0 +1,120 @@
+module Resque::Delayed
+  # a worker that harvests delayed jobs and queues them
+  #
+  # note: this is a modified version of
+  # https://github.com/defunkt/resque/blob/e01bece0ccfd561909333d51b28813d59777183d/lib/resque/worker.rb
+  # with nearly everything stripped out of it
+  class Worker
+    # Whether the worker should log basic info to STDOUT
+    attr_accessor :verbose
+
+    # Whether the worker should log lots of info to STDOUT
+    attr_accessor  :very_verbose
+
+    attr_writer :to_s
+
+    # Can be passed a float representing the polling frequency.
+    # The default is 5 seconds, but for a semi-active site you may
+    # want to use a smaller value.
+    def work(interval = 5.0)
+      interval = Float(interval)
+      $0 = "resque-delayed: harvesting"
+      startup
+
+      loop do
+        break if shutdown?
+
+        # harvest delayed jobs while they are available
+        while job = Resque::Delayed.next do
+          log "got: #{job.inspect}"
+          queue, klass, *args = job
+          Resque::Job.create(queue, klass, *args)
+        end
+
+        break if interval.zero?
+        log! "Sleeping for #{interval} seconds"
+        sleep interval
+      end
+    end
+
+    # Runs all the methods needed when a worker begins its lifecycle.
+    def startup
+      register_signal_handlers
+
+      # Fix buffering so we can `rake resque-delayed:work > resque-delayed.log` and
+      # get output from the worker
+      $stdout.sync = true
+    end
+
+    # Registers the various signal handlers a worker responds to.
+    #
+    # TERM: Shutdown immediately, stop processing jobs.
+    #  INT: Shutdown immediately, stop processing jobs.
+    # QUIT: Shutdown after the current job has finished processing.
+    def register_signal_handlers
+      trap('TERM') { shutdown! }
+      trap('INT')  { shutdown! }
+
+      begin
+        trap('QUIT') { shutdown }
+      rescue ArgumentError
+        warn "Signals TERM and/or QUIT not supported."
+      end
+
+      log! "Registered signals"
+    end
+
+    # Schedule this worker for shutdown. Will finish processing the
+    # current job.
+    def shutdown
+      log 'Exiting...'
+      @shutdown = true
+    end
+
+    # Kill the child and shutdown immediately.
+    def shutdown!
+      shutdown
+    end
+
+    # Should this worker shutdown as soon as current job is finished?
+    def shutdown?
+      @shutdown
+    end
+
+    def inspect
+      "#<Resque::Delayed worker #{to_s}>"
+    end
+
+    # The string representation is the same as the id for this worker
+    # instance. Can be used with `Worker.find`.
+    def to_s
+      @to_s ||= "#{hostname}:#{Process.pid}:resque-delayed"
+    end
+    alias_method :id, :to_s
+
+    # chomp'd hostname of this machine
+    def hostname
+      @hostname ||= `hostname`.chomp
+    end
+
+    # Returns Integer PID of running worker
+    def pid
+      @pid ||= Process.pid
+    end
+
+    # Log a message to STDOUT if we are verbose or very_verbose.
+    def log(message)
+      if verbose
+        puts "*** #{message}"
+      elsif very_verbose
+        time = Time.now.strftime('%H:%M:%S %Y-%m-%d')
+        puts "** [#{time}] #$$: #{message}"
+      end
+    end
+
+    # Logs a very verbose message to STDOUT.
+    def log!(message)
+      log message if very_verbose
+    end
+  end
+end

data/resque-delayed.gemspec

@@ -0,0 +1,24 @@
+require File.expand_path('../lib/resque-delayed/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Justin Giancola"]
+  gem.email         = ["justin.giancola@gmail.com"]
+  gem.summary       = %q{Delayed job queueing for Resque}
+  gem.description   = %q{Enqueue jobs that will only appear for processing after a specified delay or at a particular time in the future}
+  gem.homepage      = "https://github.com/elucid/resque-delayed"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "resque-delayed"
+  gem.require_paths = ["lib"]
+  gem.version       = Resque::Delayed::VERSION
+
+  gem.add_development_dependency "bundler", [">= 1.0.2", "< 1.2.0"]
+  gem.add_development_dependency "rspec", "~> 2.6.0"
+  gem.add_development_dependency "rake", [">= 0.8.7", "< 1.0"]
+
+  gem.add_dependency "redis", "~> 2.2.0"
+  gem.add_dependency "resque", [">= 1.18.0", "< 1.20.0"]
+  gem.add_dependency "uuidtools", "~> 2.1.2"
+end

data/spec/redis-test.conf

@@ -0,0 +1,8 @@
+daemonize yes
+pidfile ./spec/redis-test.pid
+port 9736
+timeout 10
+loglevel warning
+logfile /dev/null
+databases 1
+glueoutputbuf yes

data/spec/resque_delayed_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe Resque::Delayed do
+  describe 'simple create' do
+    before :each do
+      Resque::Delayed.clear
+    end
+
+    it "should start with zero delayed jobs queued" do
+      Resque::Delayed.count.should be_zero
+    end
+
+    it "should allow queueing at a specified time" do
+      Resque::Delayed.create_at(Time.now + 1.day, SomeJob, 'foo', 'bar', 1234)
+      Resque::Delayed.count.should == 1
+    end
+
+    it "should allow queuing after a specified delay" do
+      Resque::Delayed.create_in(1.day, SomeJob, 'foo', 'bar', 1234)
+      Resque::Delayed.count.should == 1
+    end
+  end
+
+  describe :availability do
+    before :each do
+      Resque::Delayed.clear
+      @one_day_from_now = Time.now + 1.day
+      Resque::Delayed.create_at(@one_day_from_now, SomeJob, 'foo', 'bar', 1234)
+    end
+
+    it "should not make items available before create time" do
+      Resque::Delayed.next.should be_nil
+      Resque::Delayed.next_at(Time.now).should be_nil
+    end
+
+    it "should make items available at create time" do
+      Resque::Delayed.next_at(@one_day_from_now).should_not be_nil
+    end
+
+    it "should make items available after create time" do
+      Resque::Delayed.next_at(@one_day_from_now + 1.minute).should_not be_nil
+    end
+  end
+
+  describe :dequeueing do
+    before do
+      Resque::Delayed.clear
+      @one_hour_ago = Time.now - 1.hour
+      Resque::Delayed.create_at(@one_hour_ago, SomeJob, 'foo', 'bar', 1234)
+    end
+
+    it "should deserialize properly" do
+      job = Resque::Delayed.next
+      job.should == ["jobs", "SomeJob", "foo", "bar", 1234]
+      Resque::Delayed.count.should be_zero
+    end
+  end
+
+  describe :updates do
+    before :each do
+      Resque::Delayed.clear
+      @one_hour_ago = Time.now - 1.hour
+      Resque::Delayed.create_at(@one_hour_ago, SomeJob, 'first')
+      Resque::Delayed.create_at(@one_hour_ago + 2.minutes, SomeJob, 'third')
+      Resque::Delayed.create_at(@one_hour_ago + 1.minute, SomeJob, 'second')
+    end
+
+    it "should be setup properly" do
+      Resque::Delayed.peek.should == ["jobs", "SomeJob", "first"]
+      Resque::Delayed.count.should == 3
+    end
+
+    it "should dequeue in the correct order regardless of instert order" do
+      %w(first second third).each do |arg|
+        Resque::Delayed.next.last.should == arg
+      end
+    end
+
+    it "should allow queueing multiple instances of the same job" do
+      Resque::Delayed.create_at(@one_hour_ago + 3.minutes, SomeJob, 'first')
+      Resque::Delayed.count.should == 4
+    end
+
+    it "should not alter position of existing jobs on second instance queue" do
+      Resque::Delayed.create_at(@one_hour_ago + 3.minutes, SomeJob, 'first')
+      Resque::Delayed.peek.should == ["jobs", "SomeJob", "first"]
+    end
+  end
+end

data/spec/resque_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Resque do
+  describe 'simple create' do
+    before :each do
+      Resque::Delayed.clear
+    end
+
+    it "should start with zero delayed jobs queued" do
+      Resque::Delayed.count.should be_zero
+    end
+
+    it "should allow queueing at a specified time" do
+      Resque.enqueue_at(Time.now + 1.day, SomeJob, 'foo', 'bar', 1234)
+      Resque::Delayed.count.should == 1
+    end
+
+    it "should allow queuing after a specified delay" do
+      Resque.enqueue_in(1.day, SomeJob, 'foo', 'bar', 1234)
+      Resque::Delayed.count.should == 1
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,41 @@
+# based on https://github.com/defunkt/resque/blob/e01bece0ccfd561909333d51b28813d59777183d/test/test_helper.rb
+
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+Bundler.require
+
+# this is necessary because of
+# https://github.com/carlhuda/bundler/issues/1096
+require 'resque'
+
+# make sure we can run redis
+if !system("which redis-server")
+  puts '', "** can't find `redis-server` in your path"
+  abort ''
+end
+
+dir = File.dirname(File.expand_path(__FILE__))
+
+# start our own redis when the tests start,
+# kill it when they end
+at_exit do
+  pid = File.read("#{dir}/redis-test.pid").chomp
+  puts "Killing test redis server..."
+  Process.kill("KILL", pid.to_i)
+  File.unlink "#{dir}/redis-test.pid"
+end
+
+puts "Starting redis for testing at localhost:9736..."
+`redis-server #{dir}/redis-test.conf`
+Resque.redis = 'localhost:9736'
+
+require "#{dir}/support/extensions.rb"
+
+class SomeJob
+  @queue = :jobs
+end
+
+class SomeOtherJob
+  @queue = :other_jobs
+end

data/spec/support/extensions.rb

@@ -0,0 +1,21 @@
+class Fixnum
+  def seconds
+    to_i
+  end
+  alias :second :seconds
+
+  def minutes
+    seconds * 60
+  end
+  alias :minute :minutes
+
+  def hours
+    minutes * 60
+  end
+  alias :hour :hours
+
+  def days
+    hours * 24
+  end
+  alias :day :days
+end

data/spec/worker_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Resque::Delayed::Worker do
+  describe "harvest timing" do
+    before :each do
+      Resque::Delayed.clear
+      @worker = Resque::Delayed::Worker.new
+    end
+
+    after :each do
+      @worker.shutdown!
+    end
+
+    it "should not harvest future jobs" do
+      Resque.enqueue_in(1.hour, SomeJob, 'future')
+      @worker.work(0)
+      Resque::Delayed.count.should == 1
+    end
+
+    it "should harvest past jobs" do
+      Resque.enqueue_at(Time.now - 1.hour, SomeJob, 'past')
+      @worker.work(0)
+      Resque::Delayed.count.should == 0
+    end
+  end
+
+  describe "Resque interface" do
+    before do
+      Resque::Delayed.clear
+      @worker = Resque::Delayed::Worker.new
+      Resque.enqueue_at(Time.now - 1.hour, SomeJob, 'past')
+      Resque.enqueue_at(Time.now - 1.hour, SomeOtherJob, 'past')
+    end
+
+    after do
+      @worker.shutdown!
+    end
+
+    it "should queue delayed jobs in appropriate Resque queues after harvest" do
+      Resque::Job.should_receive(:create).with('jobs', 'SomeJob', 'past')
+      Resque::Job.should_receive(:create).with('other_jobs', 'SomeOtherJob', 'past')
+      @worker.work(0)
+    end
+  end
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification 
+name: resque-delayed
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Justin Giancola
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-07 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.2
+    - - <
+      - !ruby/object:Gem::Version 
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.8.7
+    - - <
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: redis
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: resque
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.18.0
+    - - <
+      - !ruby/object:Gem::Version 
+        version: 1.20.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: uuidtools
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *id006
+description: Enqueue jobs that will only appear for processing after a specified delay or at a particular time in the future
+email: 
+- justin.giancola@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/resque-delayed.rb
+- lib/resque-delayed/resque-delayed.rb
+- lib/resque-delayed/resque.rb
+- lib/resque-delayed/tasks.rb
+- lib/resque-delayed/version.rb
+- lib/resque-delayed/worker.rb
+- resque-delayed.gemspec
+- spec/redis-test.conf
+- spec/resque_delayed_spec.rb
+- spec/resque_spec.rb
+- spec/spec_helper.rb
+- spec/support/extensions.rb
+- spec/worker_spec.rb
+homepage: https://github.com/elucid/resque-delayed
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -4057691847375928239
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -4057691847375928239
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.8
+signing_key: 
+specification_version: 3
+summary: Delayed job queueing for Resque
+test_files: 
+- spec/redis-test.conf
+- spec/resque_delayed_spec.rb
+- spec/resque_spec.rb
+- spec/spec_helper.rb
+- spec/support/extensions.rb
+- spec/worker_spec.rb