recurring_job 0.0.4

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.gem

data/.ruby-version

@@ -0,0 +1 @@
+ruby-1.9.3-p327

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in recurring_job.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 OL2, Inc.
+
+MIT License
+
+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,157 @@
+# RecurringJob
+
+RecurringJob creates a framework for creating custom DelayedJob jobs that are automatically rescheduled to run again.
+
+## Installation
+RecurringJob requires delayed_job_active_record ( > 4.0).
+Follow the instructions to [install DelayedJob](https://github.com/collectiveidea/delayed_job_active_record) first.
+
+Then add this line to your application's Gemfile:
+
+```ruby
+gem 'recurring_job'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install recurring_job
+
+By default, RecurringJob logs to STDOUT. If you want it to log to your rails logger, put the following somewhere in your rails configuration files
+(I use environment.rb)
+
+```ruby
+RecurringJob.logger = Rails.logger
+```
+
+## Usage
+
+RecurringJob extends the functionality of [Custom Jobs](https://github.com/collectiveidea/delayed_job#custom-jobs)
+within DelayedJob. It uses the job's queue field to identify each type of recurring job, and to ensure a single instance of each
+one is scheduled in the job queue at a time.
+
+To use RecurringJob, you need to create a custom job class for each type of job you wish to schedule.
+I like to put job classes in a `lib/jobs` folder in my rails app, but you're free to put them anywhere you like.
+
+This example, which is similar to how we use RecurringJob at OnLive, shows how to subclass the RecurringJob class and provide a `perform` method that does the actual work.
+We can send in our own options (in this example an `app_id` for a database Model named App) and those will be passed on each
+time when the job is scheduled.  In addition we are automatically passed in the job id of the DelayedJob job, which in this
+case we use for locking (Of course, you can also just ignore the job id if you don't need it!).
+
+```ruby
+class AppStatusJob < RecurringJob
+
+  def perform
+    return unless options
+    app_id = options[:app_id]
+    recurring_job_id = options[:delayed_job_id]
+
+    apps_to_process = app_id ? App.where(id:app_id) : App.all
+
+    apps_to_process.each do |app|
+      app.lock_for_status_check(recurring_job_id) do
+        # if no one else is modifying the app right now
+        # this block gets executed
+        app.do_whatever_it_means_to_check_status
+      end
+    end
+  end
+
+  def after(job)
+    super   # have to allow RecurringJob to do its work!!
+    send_email_about_job_success(job)
+  end
+
+end
+```
+We can run this job a single time to check a single app
+
+```ruby
+AppStatusJob.queue_once(app_id:App.first.id)
+```
+
+Or we can set it up to run as a scheduled job to check all apps every hour
+```ruby
+AppStatusJob.schedule_job(interval:1.hour)
+```
+
+Or we can set it up to run for each particular app on a schedule, using the (unique)
+name of the app as the name of the queue
+
+```ruby
+App.all.each do |app|
+  AppStatusJob.schedule_job(interval:1.hour, app_id:app.id, queue:app.name)
+end
+```
+
+Once AppStatusJob has been set up as a RecurringJob, the scheduled jobs will automatically add themselves back into the
+queue to run an hour after they finish (or whatever interval you choose), continuing indefinitely! And like all DelayedJobs,
+you can specify actions to happen when these jobs succeed, or fail, and the jobs live in the DelayedJob queue between runs.
+(See more info about [DelayedJob hooks](https://github.com/collectiveidea/delayed_job#hooks)).
+
+**Important:** If you implement any of the DelayedJob hooks (`before`, `after`, `success`, `error`, `failure`, or `enqueue`) in your RecurringJob, you must call super to allow the RecurringJob hooks
+to do its work!
+
+## More info
+If you want to change the interval of a job, you can call schedule_job again and it will change the
+currently scheduled job.
+```ruby
+AppStatusJob.schedule_job(interval:30.minutes)
+```
+You can stop a job from running anymore by taking it out of the queue
+```ruby
+AppStatusJob.unschedule_job
+```
+To get a list of all the RecurringJobs you have scheduled
+```ruby
+RecurringJob.all
+```
+
+## Another example
+You might want to use RecurringJob to send emails in batches,
+for example if your email service has limits to the number of API calls per day, like iPost does. If you had
+a queue of pending emails in a table called pending_emails, it might look something like this (*all actual email
+details left as an exercise for the reader*).
+
+```ruby
+class BatchEmailJob < RecurringJob
+
+  def perform
+    # send any pending emails
+    @email_status_hash = PendingEmail.send_all  # returns a hash of # emails were sent, any failures, etc
+  end
+
+  def success(job)
+    super   # allow RecurringJob to do its work!!
+
+    notify_job_succeeded(@email_status_hash)
+  end
+
+  def max_attempts
+    3
+  end
+
+end
+```
+And then set it up to run as often as you want to send the emails, say every 5 hours.
+
+```ruby
+BatchEmailJob.schedule_job(interval:5.hours)
+```
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/recurring_job/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## License and Copying
+
+Recurring Job is released under the MIT License by OL2, Inc.
+Please see the file LICENSE.txt for a copy of this license.

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/*_test.rb"]
+end

data/lib/recurring_job.rb

@@ -0,0 +1,5 @@
+# Copyright (C) 2015 OL2, Inc. See LICENSE.txt for details.
+
+require "recurring_job/recurring_job"
+require "recurring_job/version"
+

data/lib/recurring_job/class_decl.rb

@@ -0,0 +1,3 @@
+# Copyright (C) 2015 OL2, Inc. See LICENSE.txt for details.
+class RecurringJob < Struct.new(:options )
+end

data/lib/recurring_job/recurring_job.rb

@@ -0,0 +1,221 @@
+# Copyright (C) 2014-2015 OL2, Inc. See LICENSE.txt for details.
+require 'active_record'
+require 'delayed_job_active_record'
+
+require "recurring_job/class_decl"
+
+# Class declaration in recurring_job/class_decl gives the parent class,
+# which is a new Struct().
+class RecurringJob
+  # (parts inspired by https://gist.github.com/JoshMcKin/1648242)
+
+  def self.logger=(new_logger)
+    @@logger = new_logger
+  end
+
+  def self.logger
+    @@logger ||= Logger.new(STDOUT)
+    @@logger
+  end
+
+  def logger
+    RecurringJob.logger
+  end
+
+  def self.schedule_job(options = {}, this_job=nil)
+    # schedule this job (if you just want job to run once, just use queue_once )
+    # this_job is currently running instance (if any)(so we can check against it)
+    # options -
+    #   :interval => number of seconds between job runs  (from end of one to beginning of next)
+    #                default, once a day
+    #   :queue  => name of queue to use
+    #              default: the name of this class
+    #              only one job will be scheduled at a time for any given queue
+    #   :first_start_time => specify a specific time for this run, then use interval after that
+    # Plus any other options (if any) you want sent through to the underlying job.
+
+    options ||= {}  # in case sent in explicitly as nil
+    options[:interval] ||= default_interval
+    options[:queue] ||= default_queue
+
+    queue_name = options[:queue]
+    other_job = next_scheduled_job(this_job, queue_name)
+    if other_job
+      logger.info "#{queue_name} job is already scheduled for #{other_job.run_at}."
+      # Still set any new start time or interval options for next time.
+      if job_interval(other_job) != options[:interval].to_i
+        logger.info "    Updating interval to #{options[:interval]}"
+        set_job_interval(other_job, options[:interval])
+      end
+      if options[:first_start_time] && options[:first_start_time] != other_job.run_at
+        logger.info "    Updating start time to #{options[:first_start_time]}"
+
+        other_job.run_at = options[:first_start_time]
+        other_job.save
+      end
+    else
+      # if start time is specified, use it ONLY this time (to start), don't pass on in options
+      run_time = options.delete(:first_start_time)
+      run_time ||=  Time.now + options[:interval].to_i # make sure it's an integer (e.g. if sent in as 1.day)
+      other_job = Delayed::Job.enqueue self.new(options), :run_at => run_time, :queue=> queue_name
+      logger.info "The next #{queue_name} job has been scheduled for #{other_job.run_at}."
+    end
+    other_job
+  end
+
+  def self.unschedule_job
+    # shortcut for deleting the job from Delayed Job
+    # returns true if there was a job to delete, false otherwise
+    recurring_job = self.next_scheduled_job
+    recurring_job.destroy if recurring_job
+    return recurring_job  # true if there was a job to unschedule
+  end
+
+
+  def self.queue_once(options = {})
+    # just run this to add the queue to run one time only (not scheduled)
+    # IMPORTANT: don't put in same queue name as recurring job and DON'T specify an interval in the options!
+    # Can use the queue field, but do not use the job name!
+    queue = options[:queue]
+    raise "Can't run Recurring Job once in queue: #{default_queue}" if queue == default_queue
+    Delayed::Job.enqueue(self.new(options), :queue => queue)
+  end
+
+  def self.in_queue_or_running?(queue)
+    # is this job currently in progress?
+    # will return false if the job is already done
+    # (the job is out of the queue when it's done.)
+    queue ||= default_queue
+    job = Delayed::Job.find_by(queue:queue)
+    job
+  end
+
+  def self.default_interval
+    1.day
+  end
+
+  def self.default_queue
+    self.name
+  end
+
+  def self.next_scheduled_job(this_job=nil, queue_name = nil)
+    # return job if it exists
+    queue_name ||= default_queue
+    conditions = ['queue = ? AND failed_at IS NULL', queue_name]
+
+    unless this_job.blank?
+      conditions[0] << " AND id != ?"
+      conditions << this_job.id
+    end
+
+    Delayed::Job.where(conditions).first
+  end
+
+
+  def self.running?(queue=nil)
+    # is this job currently running?
+    queue ||= default_queue
+    job = Delayed::Job.find_by(queue:queue)
+    job && job.locked_by
+  end
+
+  def self.job_id_running?(job_id)
+    # is a job with the given id running?
+    job = Delayed::Job.find_by(id:job_id)  # don't use find, don't want to raise an error if not found
+    #logger.debug("Is job #{job_id} running? #{job.inspect}")
+    job && job.locked_by
+  end
+
+  def self.set_option(job, option, value)
+    # given a job from the queue,
+    # parse the handler yaml and set options[option] to value
+    y = YAML.load(job.handler)
+    y.options ||= {}
+    y.options[option] = value
+    job.handler = y.to_yaml
+    job.save!
+  end
+
+  def self.get_option(job, option)
+    # given a job from the queue,
+    # parse the handler yaml and return options[option]
+    y = YAML.load(job.handler)
+    y.options && y.options[option]
+  end
+
+  def self.job_interval(job)
+    # given a job from the queue
+    # parse the handler yaml and give back the current interval
+    # nil means no interval set
+    get_option(job, :interval)
+  end
+
+  def self.set_job_interval(job, interval)
+    # given a job from the queue
+    # parse the handler yaml and set the job interval
+    interval ||= default_interval
+    set_option(job, :interval, interval.to_i)
+  end
+
+  def self.all
+    # Return all jobs with named queues (may get extra jobs if other jobs use named queues)
+    Delayed::Job.all.where.not(queue:nil)
+  end
+
+  def self.list_job_intervals
+    # lists all jobs that have a queue associated with them and intervals (if any)
+    # {queue_name => {interval:interval, next_run:<run_at>}}
+    job_list = {}
+    self.all.each do |job|
+      queue = job.queue
+      next unless queue
+      job_list[queue] = {interval:self.job_interval(job), next_run:job.run_at}
+    end
+    job_list
+  end
+
+  def perform
+    # should be overridden by real job to do the actual work!
+    # (don't call super for this...)
+    raise "Must override perform in #{self.class.name}"
+  end
+
+  def before(job)
+    # Remember to call super if you implement this hook in your own job!
+
+    # Send in the job_id so that the RecurringJob can use it if it needs it.
+    # (during perform we otherwise don't have access to "job")
+    options[:delayed_job_id] = job.id.to_s
+  end
+
+  def after(job)
+    # Remember to call super if you implement this hook in your own job!
+
+    # Reschedule this job when we're done.  Whether there's an error in this run
+    # or not, we always want to reschedule if an interval was specified
+    if options[:interval]
+      #  if an interval was specified, make sure there's a future job using the same options as before.
+      #  Otherwise, this is a one time run so don't reschedule.
+      options.delete(:delayed_job_id) # don't pass on the previous delayed job id
+      # logger.debug("Scheduling again: #{options.inspect}")
+      self.class.schedule_job(options, job)
+    end
+  end
+
+  def success(job)
+    # Remember to call super if you implement this hook in your own job!
+  end
+
+  def error(job, exception)
+    # Remember to call super if you implement this hook in your own job!
+  end
+
+  def failure(job)
+    # Remember to call super if you implement this hook in your own job!
+  end
+
+  def enqueue(job)
+    # Remember to call super if you implement this hook in your own job!
+  end
+
+end

data/lib/recurring_job/version.rb

@@ -0,0 +1,5 @@
+# Copyright (C) 2015 OL2, Inc. See LICENSE.txt for details.
+
+require "recurring_job/class_decl"
+
+RecurringJob::VERSION = "0.0.4"

data/recurring_job.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'recurring_job/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "recurring_job"
+  spec.version       = RecurringJob::VERSION
+  spec.authors       = ["Ruth Helfinstein", "Noah Gibbs"]
+  spec.email         = ["ruth.helfinstein@onlive.com", "noah@onlive.com"]
+  spec.summary       = %q{Schedule DelayedJob tasks to repeat after a given interval.}
+  spec.description   = <<DESC
+Recurring_job creates a framework for creating custom DelayedJob jobs
+that are automatically rescheduled to run again at a given interval.
+DESC
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'activesupport', ['>= 3.0', '< 5.0']
+  spec.add_runtime_dependency 'activerecord', '>= 3.0', '< 5.0'
+  spec.add_runtime_dependency 'delayed_job_active_record', '~> 4.0'
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.4"
+  spec.add_development_dependency "rr", '~> 1.1'
+  spec.add_dependency 'sqlite3', '~> 1'
+
+end

data/test/recurring_job_test.rb

@@ -0,0 +1,208 @@
+# Copyright (C) 2014-2015 OL2, Inc. See LICENSE.txt for details.
+
+require 'test_helper'
+
+class RecurringJobTest < ActiveSupport::TestCase
+  @@last_job_id =  nil
+
+  class MyRecurringJob < RecurringJob
+    def perform
+      raise "Must have options!" unless options
+      case options[:action]
+        when :error
+          raise 'FAILING'
+        when :delay
+          logger.debug("Sleeping")
+          sleep(5)
+        when :test_id
+          logger.debug("Job id is #{options[:delayed_job_id]}")
+          RecurringJobTest.last_job_id = options[:delayed_job_id]
+        else
+         logger.debug("Performing")
+      end
+    end
+  end
+
+  def self.last_job_id=(value)
+    @@last_job_id = value
+  end
+
+  def setup
+    RecurringJob.logger.debug("------------------------------------")
+    Delayed::Job.delete_all
+  end
+
+  def test_schedule_job
+    # nothing is scheduled when we start
+    assert_nil(MyRecurringJob.next_scheduled_job)
+    # schedule a job which will run immediately and reschedule itself
+    # (since not running automatically this will work)
+    job = MyRecurringJob.schedule_job({interval:1, action: :perform, first_start_time: Time.now})
+    # now this job is scheduled
+    assert_equal(job, MyRecurringJob.next_scheduled_job)
+    assert_equal(RecurringJob.all, [job])
+    # now run the job from the queue
+    Delayed::Worker.new.work_off
+
+   # should have added a new job that's different from this one
+    job2 = MyRecurringJob.next_scheduled_job
+    assert(job2)
+    refute_equal(job2, job)
+
+    # if we try to schedule a new one now it should be the same one
+    job3 = MyRecurringJob.schedule_job({interval:1, first_start_time: Time.now})
+    assert_equal(job2, job3)
+  end
+
+  def test_failed_job
+    Delayed::Worker.max_attempts = 3 # delete after third failed attempt
+
+    worker = Delayed::Worker.new
+
+    job = MyRecurringJob.schedule_job({interval:1, action: :error})
+
+    # make sure the jobs will run now
+    RecurringJob.all.each do |j|
+      j.run_at = Time.now
+      j.save!
+    end
+    # run job, will fail
+    worker.work_off
+    RecurringJob.all.each do |j|
+      j.run_at = Time.now
+      j.save!
+    end
+
+    # there should now be two jobs in the queue
+    # since it adds the next job even if there's an error
+    assert_equal(2,RecurringJob.all.size, "Should be the new job in the queue")
+    jobs = RecurringJob.all
+    # they should both run this time and both get errors
+    worker.work_off
+
+    RecurringJob.all.each do |j|
+      j.run_at = Time.now
+      j.save!
+    end
+
+    assert_equal(jobs, RecurringJob.all)
+    # There should still only be the same two jobs in the queue.
+    assert_equal(2,RecurringJob.all.size)
+
+    worker.work_off
+    # it's been 3 attempts so original job should be deleted
+
+    RecurringJob.all.each do |j|
+      j.run_at = Time.now
+      j.save!
+    end
+
+    refute_includes(RecurringJob.all, job)
+
+    # The second job will fail a third time and get deleted, but make sure it puts a new job in the
+    # queue before it does (to show we will always have at least one job in the queue)
+    worker.work_off
+
+    refute_empty(RecurringJob.all)
+
+  end
+
+  def test_uses_different_queues
+    job = MyRecurringJob.schedule_job({interval:1, queue:'queue1'})
+    job2 = MyRecurringJob.schedule_job({interval:1})
+    refute_equal(job, job2)
+    assert_equal(job, MyRecurringJob.next_scheduled_job(nil, 'queue1'))
+    assert_equal(job2, MyRecurringJob.next_scheduled_job(nil))
+  end
+
+  def test_first_start_time
+    first_start_time = Date.today.midnight
+    job = MyRecurringJob.schedule_job({interval:1, first_start_time:first_start_time})
+    assert_equal(first_start_time, job.run_at)
+  end
+
+  def test_job_with_no_schedule
+    # run MyRecurringJob one time only with no interval set and check that it's not rescheduled
+    job = MyRecurringJob.queue_once(action: :something)
+
+    assert_equal(Delayed::Job.all, [job])
+    # now run the job from the queue
+    Delayed::Worker.new.work_off
+
+    # There should be no jobs in the queue (wasn't rescheduled)
+    assert_empty(Delayed::Job.all, "Queue should be empty")
+  end
+
+  def test_get_and_set_interval
+    job = MyRecurringJob.schedule_job
+    interval = MyRecurringJob.job_interval(job)
+    assert_equal(interval, MyRecurringJob.default_interval)
+
+    refute_equal(interval, 0)
+
+    MyRecurringJob.set_job_interval(job, 0)
+    job.reload # make sure it saved the change
+    assert_equal(0, MyRecurringJob.job_interval(job))
+
+  end
+
+  def test_schedule_job_new_interval
+    # nothing is scheduled when we start
+    assert_nil(MyRecurringJob.next_scheduled_job)
+    # schedule a job which will run immediately and reschedule itself immediately
+    # (since not running automatically this will work)
+    job = MyRecurringJob.schedule_job({interval:1})
+    # now this job is scheduled
+    assert_equal(job, MyRecurringJob.next_scheduled_job)
+    assert_equal(1, MyRecurringJob.job_interval(job))
+
+    job2 = MyRecurringJob.schedule_job({interval:0})
+    assert_equal(job, job2)  # same object
+    assert_equal(0, MyRecurringJob.job_interval(job2))
+
+    job3 = MyRecurringJob.schedule_job({interval:1})
+    assert_equal(job, job3)  # same object
+    assert_equal(1, MyRecurringJob.job_interval(job3))
+
+
+  end
+
+  def test_schedule_job_new_first_start_time
+    # nothing is scheduled when we start
+    assert_nil(MyRecurringJob.next_scheduled_job)
+
+    time1 = Time.now + 1.day
+    job = MyRecurringJob.schedule_job({first_start_time:time1})
+    # now this job is scheduled
+    assert_equal(job, MyRecurringJob.next_scheduled_job)
+    assert_equal(time1.to_i, job.run_at.to_i)
+
+    job2 = MyRecurringJob.schedule_job({interval:0})  # no start time
+    assert_equal(job, job2)  # same object
+    assert_equal(time1.to_i, job2.run_at.to_i)
+
+    time2 = Time.now
+    job3 = MyRecurringJob.schedule_job({first_start_time:time2})
+    assert_equal(job, job3)  # same object
+    assert_equal(time2.to_i, job3.run_at.to_i)
+  end
+
+  def test_job_id
+    # make sure the delayed job id is available to the job.
+    assert_empty(RecurringJob.all)
+
+    RecurringJobTest.last_job_id = nil
+    job = MyRecurringJob.schedule_job({interval:1, action: :test_id, first_start_time: Time.now})
+    assert_equal(RecurringJob.all, [job])
+
+    refute(MyRecurringJob.get_option(job, :delayed_job_id))  # it's set only when the job is running
+    assert_equal(:test_id, MyRecurringJob.get_option(job, :action))
+
+    # now run the job from the queue
+    Delayed::Worker.new.work_off
+
+    assert_equal(job.id, @@last_job_id.to_i)
+
+  end
+
+end

data/test/support/db.rb

@@ -0,0 +1,21 @@
+# Copyright (C) 2015 OL2, Inc. See LICENSE.txt for details.
+
+# set up database just for testing. When using the gem, users will set up
+# the database structure when setting up delayed job to work with their code and
+# we use that same database.
+ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => ':memory:'
+
+# set up the DelayedJob schema in our test database
+ActiveRecord::Base.connection.create_table "delayed_jobs", force: true do |t|
+  t.integer  "priority",   default: 0, null: false
+  t.integer  "attempts",   default: 0, null: false
+  t.text     "handler",                null: false
+  t.text     "last_error"
+  t.datetime "run_at"
+  t.datetime "locked_at"
+  t.datetime "failed_at"
+  t.string   "locked_by"
+  t.string   "queue"
+  t.datetime "created_at"
+  t.datetime "updated_at"
+end

data/test/test_helper.rb

@@ -0,0 +1,30 @@
+# Copyright (C) 2015 OL2, Inc. See LICENSE.txt for details.
+
+# Test local copy first
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require "rr"
+require 'active_support/dependencies'
+require 'active_record'
+require 'logger'
+
+require "support/db"
+require "recurring_job"
+require 'minitest/autorun'
+
+require 'tempfile'
+
+if !Dir.exists?('tmp')
+  Dir.mkdir('tmp')
+end
+RecurringJob.logger = Logger.new('tmp/rj_test.log')
+
+ENV['RAILS_ENV'] = 'test'
+
+
+ActiveSupport::TestCase.test_order = :random
+ActiveRecord::Base.logger = RecurringJob.logger
+ActiveSupport::LogSubscriber.colorize_logging = false
+
+
+

metadata

@@ -0,0 +1,209 @@
+--- !ruby/object:Gem::Specification
+name: recurring_job
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+  prerelease: 
+platform: ruby
+authors:
+- Ruth Helfinstein
+- Noah Gibbs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: delayed_job_active_record
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.4'
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+description: ! 'Recurring_job creates a framework for creating custom DelayedJob jobs
+
+  that are automatically rescheduled to run again at a given interval.
+
+'
+email:
+- ruth.helfinstein@onlive.com
+- noah@onlive.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-version
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/recurring_job.rb
+- lib/recurring_job/class_decl.rb
+- lib/recurring_job/recurring_job.rb
+- lib/recurring_job/version.rb
+- recurring_job.gemspec
+- test/recurring_job_test.rb
+- test/support/db.rb
+- test/test_helper.rb
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Schedule DelayedJob tasks to repeat after a given interval.
+test_files:
+- test/recurring_job_test.rb
+- test/support/db.rb
+- test/test_helper.rb