delayed_cron_job 0.5.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ODRhZWVmNmIyMGVjMzEyOTIzZWVmNzUzMWYzNjZjMTZkNTM3YmJkOA==
+  data.tar.gz: !binary |-
+    ZTQ5MDhjZTE1NjMyNjcxZTg3Yzk1YjA3OGJjYTgwN2M0OWU4YzJmYQ==
+SHA512:
+  metadata.gz: !binary |-
+    ZmEwOGJjMGU3ZWE4NmU2ZDQ0MGQ4Y2I2NWFiOThkMTgwMWUwZDllNzE0NWQ0
+    MmU4YTczZTM1OGUwZmMwOWZkZGZhZDViY2M5YjA2YmEzODJjMmNkMzMwY2Iz
+    M2ZkOGQyN2M1ZDRmZWY0ZTJmZjExZjE5NmZlODRiNTIwNzMzNWQ=
+  data.tar.gz: !binary |-
+    YTY4NGZiNjE1Njg1NGViZTU4NjkxZTIyNzE4OTYzYjFkMGJjMjc4NzMzNzJj
+    ODA0NDg3NjYzM2EzZmYxNjhiMDdiOTE4ODAyYjY3Y2Q4YTFjMGE2NzQ3ZmNm
+    ZDA0MGQxN2MxMDVkZmU0ZWEzNjBjNjU0NDk0YzQ3MGEwZDZkMTc=

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--warnings
+--require spec_helper

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in delayed_cron_job.gemspec
+gemspec
+
+group :test do
+  gem 'pry-debugger'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Pascal Zumkehr
+
+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,63 @@
+# Delayed::Cron::Job
+
+Delayed::Cron::Job is an extension to Delayed::Job that allows you to set
+cron expressions for your jobs to run repeatedly.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'delayed_cron_job'
+
+And then execute:
+
+    $ bundle
+
+If you are using `delayed_job_active_record`, generate a migration (after the
+original delayed job migration) to add the `cron` column to the `delayed_jobs`
+table:
+
+    $ rails generate delayed_jobs:cron
+    $ rake db:migrate
+
+There are no additional steps for `delayed_job_mongoid`.
+
+## Usage
+
+When enqueuing a job, simply pass the `cron` option, e.g.:
+
+    Delayed::Job.enqueue(MyRepeatedJob.new, cron: '15 */6 * * 1-5')
+
+Any crontab compatible cron expressions are supported (see `man 5 crontab`).
+The credits for the `Cronline` class used go to
+[rufus-scheduler](https://github.com/jmettraux/rufus-scheduler).
+
+## Details
+
+The initial `run_at` value is computed during the `#enqueue` method call.
+If you create `Delayed::Job` database entries directly, make sure to set
+`run_at` accordingly.
+
+You may use the `id` of the `Delayed::Job` as returned by the `#enqueue` method
+to reference and/or remove the scheduled job in the future.
+
+The subsequent run of a job is only scheduled after the current run has
+terminated. If a single run takes longer than the given execution interval,
+some runs may be skipped. E.g., if a run takes five minutes, but the job is
+scheduled to be executed every second minute, it will actually only execute
+every sixth minute: With a cron of `*/2 * * * *`, if the current run starts at
+`:00` and finishes at `:05`, then the next scheduled execution time is at `:06`,
+and so on.
+
+If you do not want longer running jobs to skip executions, simply create a
+lightweight master job that enqueues the actual workload as separate jobs.
+Of course you have to make sure to start enough workers to handle all these
+jobs.
+
+## Contributing
+
+1. Fork it ( https://github.com/codez/delayed_cron_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

data/Rakefile

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

data/delayed_cron_job.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'delayed_cron_job/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "delayed_cron_job"
+  spec.version       = DelayedCronJob::VERSION
+  spec.authors       = ["Pascal Zumkehr"]
+  spec.email         = ["spam@codez.ch"]
+  spec.summary       = %q{An extension to Delayed::Job that allows you to set
+                          cron expressions for your jobs to run regularly.}
+  spec.description   = %q{Delayed Cron Job is an extension to Delayed::Job
+                          that allows you to set cron expressions for your
+                          jobs to run regularly.}
+  spec.homepage      = "https://github.com/codez/delayed_cron_job"
+  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_dependency "delayed_job"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "delayed_job_active_record"
+end

data/lib/delayed_cron_job.rb

@@ -0,0 +1,15 @@
+require 'delayed_job'
+require 'english'
+require 'delayed_cron_job/cronline'
+require 'delayed_cron_job/plugin'
+require 'delayed_cron_job/version'
+
+module DelayedCronJob
+
+end
+
+if defined?(Delayed::Backend::Mongoid)
+  Delayed::Backend::Mongoid::Job.field :cron, :type => String
+end
+
+DelayedCronJob::Plugin.callback_block.call(Delayed::Worker.lifecycle)

data/lib/delayed_cron_job/cronline.rb

@@ -0,0 +1,465 @@
+#--
+# Copyright (c) 2006-2014, John Mettraux, jmettraux@gmail.com
+#
+# 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.
+#
+# Made in Japan.
+#++
+
+
+module DelayedCronJob
+
+  #
+  # A 'cron line' is a line in the sense of a crontab
+  # (man 5 crontab) file line.
+  #
+  class Cronline
+
+    # The string used for creating this cronline instance.
+    #
+    attr_reader :original
+
+    attr_reader :seconds
+    attr_reader :minutes
+    attr_reader :hours
+    attr_reader :days
+    attr_reader :months
+    attr_reader :weekdays
+    attr_reader :monthdays
+    attr_reader :timezone
+
+    def initialize(line)
+
+      raise ArgumentError.new(
+        "not a string: #{line.inspect}"
+      ) unless line.is_a?(String)
+
+      @original = line
+
+      items = line.split
+
+      @timezone = (TZInfo::Timezone.get(items.last) rescue nil)
+      items.pop if @timezone
+
+      raise ArgumentError.new(
+        "not a valid cronline : '#{line}'"
+      ) unless items.length == 5 or items.length == 6
+
+      offset = items.length - 5
+
+      @seconds = offset == 1 ? parse_item(items[0], 0, 59) : [ 0 ]
+      @minutes = parse_item(items[0 + offset], 0, 59)
+      @hours = parse_item(items[1 + offset], 0, 24)
+      @days = parse_item(items[2 + offset], 1, 31)
+      @months = parse_item(items[3 + offset], 1, 12)
+      @weekdays, @monthdays = parse_weekdays(items[4 + offset])
+
+      [ @seconds, @minutes, @hours, @months ].each do |es|
+
+        raise ArgumentError.new(
+          "invalid cronline: '#{line}'"
+        ) if es && es.find { |e| ! e.is_a?(Fixnum) }
+      end
+    end
+
+    # Returns true if the given time matches this cron line.
+    #
+    def matches?(time)
+
+      time = Time.at(time) unless time.kind_of?(Time)
+
+      time = @timezone.utc_to_local(time.getutc) if @timezone
+
+      return false unless sub_match?(time, :sec, @seconds)
+      return false unless sub_match?(time, :min, @minutes)
+      return false unless sub_match?(time, :hour, @hours)
+      return false unless date_match?(time)
+      true
+    end
+
+    # Returns the next time that this cron line is supposed to 'fire'
+    #
+    # This is raw, 3 secs to iterate over 1 year on my macbook :( brutal.
+    # (Well, I was wrong, takes 0.001 sec on 1.8.7 and 1.9.1)
+    #
+    # This method accepts an optional Time parameter. It's the starting point
+    # for the 'search'. By default, it's Time.now
+    #
+    # Note that the time instance returned will be in the same time zone that
+    # the given start point Time (thus a result in the local time zone will
+    # be passed if no start time is specified (search start time set to
+    # Time.now))
+    #
+    #   Rufus::Scheduler::CronLine.new('30 7 * * *').next_time(
+    #     Time.mktime(2008, 10, 24, 7, 29))
+    #   #=> Fri Oct 24 07:30:00 -0500 2008
+    #
+    #   Rufus::Scheduler::CronLine.new('30 7 * * *').next_time(
+    #     Time.utc(2008, 10, 24, 7, 29))
+    #   #=> Fri Oct 24 07:30:00 UTC 2008
+    #
+    #   Rufus::Scheduler::CronLine.new('30 7 * * *').next_time(
+    #     Time.utc(2008, 10, 24, 7, 29)).localtime
+    #   #=> Fri Oct 24 02:30:00 -0500 2008
+    #
+    # (Thanks to K Liu for the note and the examples)
+    #
+    def next_time(from=Time.now)
+
+      time = local_time(from)
+      time = round_to_seconds(time)
+
+      # start at the next second
+      time = time + 1
+
+      loop do
+        unless date_match?(time)
+          dst = time.isdst
+          time += (24 - time.hour) * 3600 - time.min * 60 - time.sec
+          time -= 3600 if time.isdst != dst # not necessary for winter, but...
+          next
+        end
+        unless sub_match?(time, :hour, @hours)
+          time += (60 - time.min) * 60 - time.sec; next
+        end
+        unless sub_match?(time, :min, @minutes)
+          time += 60 - time.sec; next
+        end
+        unless sub_match?(time, :sec, @seconds)
+          time += 1; next
+        end
+
+        break
+      end
+
+      global_time(time, from.utc?)
+
+    rescue TZInfo::PeriodNotFound
+
+      next_time(from + 3600)
+    end
+
+    # Returns the previous time the cronline matched. It's like next_time, but
+    # for the past.
+    #
+    def previous_time(from=Time.now)
+
+      time = local_time(from)
+      time = round_to_seconds(time)
+
+      # start at the previous second
+      time = time - 1
+
+      loop do
+        unless date_match?(time)
+          time -= time.hour * 3600 + time.min * 60 + time.sec + 1; next
+        end
+        unless sub_match?(time, :hour, @hours)
+          time -= time.min * 60 + time.sec + 1; next
+        end
+        unless sub_match?(time, :min, @minutes)
+          time -= time.sec + 1; next
+        end
+        unless sub_match?(time, :sec, @seconds)
+          time -= 1; next
+        end
+
+        break
+      end
+
+      global_time(time, from.utc?)
+
+    rescue TZInfo::PeriodNotFound
+
+      previous_time(time)
+    end
+
+    # Returns an array of 6 arrays (seconds, minutes, hours, days,
+    # months, weekdays).
+    # This method is used by the cronline unit tests.
+    #
+    def to_array
+
+      [
+        @seconds,
+        @minutes,
+        @hours,
+        @days,
+        @months,
+        @weekdays,
+        @monthdays,
+        @timezone ? @timezone.name : nil
+      ]
+    end
+
+    # Returns a quickly computed approximation of the frequency for this
+    # cron line.
+    #
+    # #brute_frequency, on the other hand, will compute the frequency by
+    # examining a whole, that can take more than seconds for a seconds
+    # level cron...
+    #
+    def frequency
+
+      return brute_frequency unless @seconds && @seconds.length > 1
+
+      delta = 60
+      prev = @seconds[0]
+
+      @seconds[1..-1].each do |sec|
+        d = sec - prev
+        delta = d if d < delta
+      end
+
+      delta
+    end
+
+    # Returns the shortest delta between two potential occurences of the
+    # schedule described by this cronline.
+    #
+    # .
+    #
+    # For a simple cronline like "*/5 * * * *", obviously the frequency is
+    # five minutes. Why does this method look at a whole year of #next_time ?
+    #
+    # Consider "* * * * sun#2,sun#3", the computed frequency is 1 week
+    # (the shortest delta is the one between the second sunday and the third
+    # sunday). This method takes no chance and runs next_time for the span
+    # of a whole year and keeps the shortest.
+    #
+    # Of course, this method can get VERY slow if you call on it a second-
+    # based cronline...
+    #
+    # Since it's a rarely used method, I haven't taken the time to make it
+    # smarter/faster.
+    #
+    # One obvious improvement would be to cache the result once computed...
+    #
+    # See https://github.com/jmettraux/rufus-scheduler/issues/89
+    # for a discussion about this method.
+    #
+    def brute_frequency
+
+      delta = 366 * DAY_S
+
+      t0 = previous_time(Time.local(2000, 1, 1))
+
+      loop do
+
+        break if delta <= 1
+        break if delta <= 60 && @seconds && @seconds.size == 1
+
+        t1 = next_time(t0)
+        d = t1 - t0
+        delta = d if d < delta
+
+        break if @months == nil && t1.month == 2
+        break if t1.year == 2001
+
+        t0 = t1
+      end
+
+      delta
+    end
+
+    protected
+
+    WEEKDAYS = %w[ sun mon tue wed thu fri sat ]
+    DAY_S = 24 * 3600
+    WEEK_S = 7 * DAY_S
+
+    def parse_weekdays(item)
+
+      return nil if item == '*'
+
+      items = item.downcase.split(',')
+
+      weekdays = nil
+      monthdays = nil
+
+      items.each do |it|
+
+        if m = it.match(/^(.+)#(l|-?[12345])$/)
+
+          raise ArgumentError.new(
+            "ranges are not supported for monthdays (#{it})"
+          ) if m[1].index('-')
+
+          expr = it.gsub(/#l/, '#-1')
+
+          (monthdays ||= []) << expr
+
+        else
+
+          expr = it.dup
+          WEEKDAYS.each_with_index { |a, i| expr.gsub!(/#{a}/, i.to_s) }
+
+          raise ArgumentError.new(
+            "invalid weekday expression (#{it})"
+          ) if expr !~ /^0*[0-7](-0*[0-7])?$/
+
+          its = expr.index('-') ? parse_range(expr, 0, 7) : [ Integer(expr) ]
+          its = its.collect { |i| i == 7 ? 0 : i }
+
+          (weekdays ||= []).concat(its)
+        end
+      end
+
+      weekdays = weekdays.uniq if weekdays
+
+      [ weekdays, monthdays ]
+    end
+
+    def parse_item(item, min, max)
+
+      return nil if item == '*'
+
+      r = item.split(',').map { |i| parse_range(i.strip, min, max) }.flatten
+
+      raise ArgumentError.new(
+        "found duplicates in #{item.inspect}"
+      ) if r.uniq.size < r.size
+
+      r
+    end
+
+    RANGE_REGEX = /^(\*|\d{1,2})(?:-(\d{1,2}))?(?:\/(\d{1,2}))?$/
+
+    def parse_range(item, min, max)
+
+      return %w[ L ] if item == 'L'
+
+      item = '*' + item if item.match(/^\//)
+
+      m = item.match(RANGE_REGEX)
+
+      raise ArgumentError.new(
+        "cannot parse #{item.inspect}"
+      ) unless m
+
+      sta = m[1]
+      sta = sta == '*' ? min : sta.to_i
+
+      edn = m[2]
+      edn = edn ? edn.to_i : sta
+      edn = max if m[1] == '*'
+
+      inc = m[3]
+      inc = inc ? inc.to_i : 1
+
+      raise ArgumentError.new(
+        "#{item.inspect} is not in range #{min}..#{max}"
+      ) if sta < min || edn > max
+
+      r = []
+      val = sta
+
+      loop do
+        v = val
+        v = 0 if max == 24 && v == 24
+        r << v
+        break if inc == 1 && val == edn
+        val += inc
+        break if inc > 1 && val > edn
+        val = min if val > max
+      end
+
+      r.uniq
+    end
+
+    def sub_match?(time, accessor, values)
+
+      value = time.send(accessor)
+
+      return true if values.nil?
+      return true if values.include?('L') && (time + DAY_S).day == 1
+
+      return true if value == 0 && accessor == :hour && values.include?(24)
+
+      values.include?(value)
+    end
+
+    def monthday_match?(date, values)
+
+      return true if values.nil?
+
+      today_values = monthdays(date)
+
+      (today_values & values).any?
+    end
+
+    def date_match?(date)
+
+      return false unless sub_match?(date, :day, @days)
+      return false unless sub_match?(date, :month, @months)
+      return false unless sub_match?(date, :wday, @weekdays)
+      return false unless monthday_match?(date, @monthdays)
+      true
+    end
+
+    def monthdays(date)
+
+      pos = 1
+      d = date.dup
+
+      loop do
+        d = d - WEEK_S
+        break if d.month != date.month
+        pos = pos + 1
+      end
+
+      neg = -1
+      d = date.dup
+
+      loop do
+        d = d + WEEK_S
+        break if d.month != date.month
+        neg = neg - 1
+      end
+
+      [ "#{WEEKDAYS[date.wday]}##{pos}", "#{WEEKDAYS[date.wday]}##{neg}" ]
+    end
+
+    def local_time(time)
+
+      @timezone ? @timezone.utc_to_local(time.getutc) : time
+    end
+
+    def global_time(time, from_in_utc)
+
+      if @timezone
+        time =
+          begin
+            @timezone.local_to_utc(time)
+          rescue TZInfo::AmbiguousTime
+            @timezone.local_to_utc(time, time.isdst)
+          end
+        time = time.getlocal unless from_in_utc
+      end
+
+      time
+    end
+
+    def round_to_seconds(time)
+
+      # Ruby 1.8 doesn't have #round
+      time.respond_to?(:round) ? time.round : time - time.usec * 1e-6
+    end
+  end
+end

data/lib/delayed_cron_job/plugin.rb

@@ -0,0 +1,58 @@
+module DelayedCronJob
+  class Plugin < Delayed::Plugin
+
+    class << self
+      def next_run_at(job)
+        job.run_at = Cronline.new(job.cron).next_time(Delayed::Job.db_time_now)
+      end
+
+      def cron?(job)
+        job.cron.present?
+      end
+    end
+
+    callbacks do |lifecycle|
+      # Calculate the next run_at based on the cron attribute before enqueue.
+      lifecycle.before(:enqueue) do |job|
+        next_run_at(job) if cron?(job)
+      end
+
+      # Prevent rescheduling of failed jobs as this is already done
+      # after perform.
+      lifecycle.around(:error) do |worker, job, &block|
+        if cron?(job)
+          job.last_error = "#{$ERROR_INFO.message}\n#{$ERROR_INFO.backtrace.join("\n")}"
+          worker.job_say(job,
+                         "FAILED with #{$ERROR_INFO.class.name}: #{$ERROR_INFO.message}",
+                         Logger::ERROR)
+          job.destroy
+        else
+          # No cron job - proceed as normal
+          block.call(worker, job)
+        end
+      end
+
+      # Reset the last_error to have the correct status of the last run.
+      lifecycle.before(:perform) do |worker, job|
+        if cron?(job)
+          job.last_error = nil
+        end
+      end
+
+      # Schedule the next run based on the cron attribute.
+      lifecycle.after(:perform) do |worker, job|
+        if cron?(job)
+          next_job = job.dup
+          next_job.id = job.id
+          next_job.created_at = job.created_at
+          next_job.locked_at = nil
+          next_job.locked_by = nil
+          next_job.attempts += 1
+          next_run_at(next_job)
+          next_job.save!
+        end
+      end
+    end
+
+  end
+end

data/lib/delayed_cron_job/version.rb

@@ -0,0 +1,3 @@
+module DelayedCronJob
+  VERSION = "0.5.0"
+end

data/lib/generators/delayed_job/cron_generator.rb

@@ -0,0 +1,22 @@
+require 'generators/delayed_job/delayed_job_generator'
+require 'generators/delayed_job/next_migration_version'
+require 'rails/generators/migration'
+require 'rails/generators/active_record'
+
+# Extend the DelayedJobGenerator so that it creates an AR migration
+module DelayedJob
+  class CronGenerator < ::DelayedJobGenerator
+    include Rails::Generators::Migration
+    extend NextMigrationVersion
+
+    self.source_paths << File.join(File.dirname(__FILE__), 'templates')
+
+    def create_migration_file
+      migration_template('cron_migration.rb', 'db/migrate/add_cron_to_delayed_jobs.rb')
+    end
+
+    def self.next_migration_number(dirname)
+      ActiveRecord::Generators::Base.next_migration_number(dirname)
+    end
+  end
+end

data/lib/generators/delayed_job/templates/cron_migration.rb

@@ -0,0 +1,9 @@
+class AddCronToDelayedJobs < ActiveRecord::Migration
+  def self.up
+    add_column :delayed_jobs, :cron, :string
+  end
+
+  def self.down
+    remove_column :delayed_jobs, :cron
+  end
+end

data/spec/delayed_cron_job_spec.rb

@@ -0,0 +1,163 @@
+
+
+describe DelayedCronJob do
+
+  class TestJob
+    def perform; end
+  end
+
+  before { Delayed::Job.delete_all }
+
+  let(:cron)    { '5 1 * * *' }
+  let(:handler) { TestJob.new }
+  let(:job)     { Delayed::Job.enqueue(handler, cron: cron) }
+  let(:worker)  { Delayed::Worker.new }
+  let(:now)     { Delayed::Job.db_time_now }
+  let(:next_run) do
+    run = now.hour * 60 + now.min >= 65 ? now + 1.day : now
+    Time.utc(run.year, run.month, run.day, 1, 5)
+  end
+
+  context 'with cron' do
+    it 'sets run_at on enqueue' do
+      expect { job }.to change { Delayed::Job.count }.by(1)
+      expect(job.run_at).to eq(next_run)
+    end
+
+    it 'enqueue fails with invalid cron' do
+      expect { Delayed::Job.enqueue(handler, cron: 'no valid cron') }.
+        to raise_error(ArgumentError)
+    end
+
+    it 'schedules a new job after success' do
+      job.update_column(:run_at, now)
+
+      worker.work_off
+
+      expect(Delayed::Job.count).to eq(1)
+      j = Delayed::Job.first
+      expect(j.id).to eq(job.id)
+      expect(j.cron).to eq(job.cron)
+      expect(j.run_at).to eq(next_run)
+      expect(j.attempts).to eq(1)
+      expect(j.last_error).to eq(nil)
+      expect(j.created_at).to eq(job.created_at)
+    end
+
+    it 'schedules a new job after failure' do
+      allow_any_instance_of(TestJob).to receive(:perform).and_raise('Fail!')
+      job.update(run_at: now)
+
+      worker.work_off
+
+      expect(Delayed::Job.count).to eq(1)
+      j = Delayed::Job.first
+      expect(j.id).to eq(job.id)
+      expect(j.cron).to eq(job.cron)
+      expect(j.run_at).to eq(next_run)
+      expect(j.last_error).to match('Fail!')
+      expect(j.created_at).to eq(job.created_at)
+    end
+
+    it 'schedules a new job after timeout' do
+      Delayed::Worker.max_run_time = 1.second
+      job.update_column(:run_at, now)
+      allow_any_instance_of(TestJob).to receive(:perform) { sleep 2 }
+
+      worker.work_off
+
+      expect(Delayed::Job.count).to eq(1)
+      j = Delayed::Job.first
+      expect(j.id).to eq(job.id)
+      expect(j.cron).to eq(job.cron)
+      expect(j.run_at).to eq(next_run)
+      expect(j.attempts).to eq(1)
+      expect(j.last_error).to match("execution expired")
+    end
+
+    it 'schedules new job after deserialization error' do
+      Delayed::Worker.max_run_time = 1.second
+      job.update_column(:run_at, now)
+      allow_any_instance_of(TestJob).to receive(:perform).and_raise(Delayed::DeserializationError)
+
+      worker.work_off
+
+      expect(Delayed::Job.count).to eq(1)
+      j = Delayed::Job.first
+      expect(j.last_error).to match("Delayed::DeserializationError")
+    end
+
+    it 'has empty last_error after success' do
+      job.update(run_at: now, last_error: 'Last error')
+
+      worker.work_off
+
+      j = Delayed::Job.first
+      expect(j.last_error).to eq(nil)
+    end
+
+    it 'has correct last_error after success' do
+      allow_any_instance_of(TestJob).to receive(:perform).and_raise('Fail!')
+      job.update(run_at: now, last_error: 'Last error')
+
+      worker.work_off
+
+      j = Delayed::Job.first
+      expect(j.last_error).to match('Fail!')
+    end
+
+    it 'uses correct db time for next run' do
+      if Time.now != now
+        job = Delayed::Job.enqueue(handler, cron: '* * * * *')
+        run = now.hour == 23 && now.min == 59 ? now + 1.day : now
+        hour = now.min == 59 ? (now.hour + 1) % 24 : now.hour
+        run_at = Time.utc(run.year, run.month, run.day, hour, (now.min + 1) % 60)
+        expect(job.run_at).to eq(run_at)
+      else
+        pending "This test only makes sense in non-UTC time zone"
+      end
+    end
+
+    it 'increases attempts on each run' do
+      job.update(run_at: now, attempts: 3)
+
+      worker.work_off
+
+      j = Delayed::Job.first
+      expect(j.attempts).to eq(4)
+    end
+
+    it 'is not stopped by max attempts' do
+      job.update(run_at: now, attempts: Delayed::Worker.max_attempts + 1)
+
+      worker.work_off
+
+      expect(Delayed::Job.count).to eq(1)
+      j = Delayed::Job.first
+      expect(j.attempts).to eq(job.attempts + 1)
+    end
+  end
+
+  context 'without cron' do
+    it 'reschedules the original job after a single failure' do
+      allow_any_instance_of(TestJob).to receive(:perform).and_raise('Fail!')
+      job = Delayed::Job.enqueue(handler)
+
+      worker.work_off
+
+      expect(Delayed::Job.count).to eq(1)
+      j = Delayed::Job.first
+      expect(j.id).to eq(job.id)
+      expect(j.cron).to eq(nil)
+      expect(j.last_error).to match('Fail!')
+    end
+
+    it 'does not reschedule a job after a successful run' do
+      job = Delayed::Job.enqueue(handler)
+
+      worker.work_off
+
+      expect(Delayed::Job.count).to eq(0)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,109 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, make a
+# separate helper file that requires this one and then use it only in the specs
+# that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+
+require 'delayed_job_active_record'
+require 'delayed_cron_job'
+require 'pry'
+
+Delayed::Worker.logger = Logger.new('/tmp/dj.log')
+ENV['RAILS_ENV'] = 'test'
+
+ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => ':memory:'
+ActiveRecord::Base.logger = Delayed::Worker.logger
+ActiveRecord::Migration.verbose = false
+
+ActiveRecord::Schema.define do
+  create_table :delayed_jobs, :force => true do |t|
+    t.integer  :priority, :default => 0
+    t.integer  :attempts, :default => 0
+    t.text     :handler
+    t.text     :last_error
+    t.datetime :run_at
+    t.datetime :locked_at
+    t.datetime :failed_at
+    t.string   :locked_by
+    t.string   :queue
+    t.string   :cron
+    t.timestamps
+  end
+
+  add_index :delayed_jobs, [:priority, :run_at], :name => 'delayed_jobs_priority'
+end
+
+
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+    expectations.syntax = :expect
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+    mocks.syntax = :expect
+
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended.
+    mocks.verify_partial_doubles = true
+  end
+=end
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: delayed_cron_job
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Pascal Zumkehr
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: delayed_job
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: delayed_job_active_record
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "Delayed Cron Job is an extension to Delayed::Job\n                          that
+  allows you to set cron expressions for your\n                          jobs to run
+  regularly."
+email:
+- spam@codez.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- delayed_cron_job.gemspec
+- lib/delayed_cron_job.rb
+- lib/delayed_cron_job/cronline.rb
+- lib/delayed_cron_job/plugin.rb
+- lib/delayed_cron_job/version.rb
+- lib/generators/delayed_job/cron_generator.rb
+- lib/generators/delayed_job/templates/cron_migration.rb
+- spec/delayed_cron_job_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/codez/delayed_cron_job
+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.2.2
+signing_key: 
+specification_version: 4
+summary: An extension to Delayed::Job that allows you to set cron expressions for
+  your jobs to run regularly.
+test_files:
+- spec/delayed_cron_job_spec.rb
+- spec/spec_helper.rb
+has_rdoc: