scheduled_job 0.0.9 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4e237cb5535336997a5bc97f2ccc0092f038ce5c
-  data.tar.gz: dd0f0331da06bf19651c16b3216fa2f29fb778a5
+  metadata.gz: 8992a23a08c1f37078a3f9a41e3e79807ccdcd86
+  data.tar.gz: f0fa25cd3bd9e27fb4b827a76e0c581f558ea451
 SHA512:
-  metadata.gz: c581219617e217ca776697a98fac4b82b6369a1cb317b90c9f2509c148d1ce599173d7f7443f4b0af65324bfe0fb2ae39ddebeae3157c9c9264c9c22ff884cd1
-  data.tar.gz: 8f7718d33ca84cad2ae07a12705b8781a14d01230b1e3f5ac96b7806ca2a477b140ec480e0ec7d99e939d4312ec4619450dd7503f336799c1f74d361d18bac8c
+  metadata.gz: 3bdada7d253e3124f3ef9ac9e303015a80082a8e3ef3ba61a2f34a30c9b6de9ee3e9ad238484e2d280b4b1bad61efc07144611f56f942b18d80c53d481a98b4e
+  data.tar.gz: b7da6a1ed79dab91050c9bec04668117b37ec2688f7726aeca25b99b8f5f76590ec2269b454bc68b218b0d24e02a831876aaca816804dd62b75d1aff379e2ea4

data/CHANGELOG.md

@@ -1,2 +1,24 @@
 # 0.0.2
 Initial public release
+
+# 0.0.3
+Removing hard coded Delayed Job dependencies
+
+# 0.0.4
+Adds one second back off to the fast mode
+
+# 0.0.5
+Removed the compulsory .configure call
+
+# 0.0.7
+Fixes substring job lookup bug
+
+# 0.0.8
+Bug fix for multiple scheduling potential
+
+# 0.0.9
+Adds local db for development
+
+# 0.1.0
+Makes available the `rake jobs:reschedule` rake task
+Adds a config to allow the scheduling for more than one instance of the same job

data/README.md

@@ -92,7 +92,7 @@ First you must include the scheduled job module in any DelayedJob that needs to
 include ::ScheduledJob
 ```
 
-Then you need to say what the job is acutally to do. This is done by implementing the permform method.
+Then you need to say what the job is actually to do. This is done by implementing the perform method.
 
 ```ruby
 def perform
@@ -100,7 +100,7 @@ def perform
 end
 ```
 
-Finaly we need to write the logic for when we want the job to run. This is done by implementing the time_to_recur method which is passed the time the job last completed as its parameter.
+Finally we need to write the logic for when we want the job to run. This is done by implementing the time_to_recur method which is passed the time the job last completed as its parameter.
 
 ```ruby
 def self.time_to_recur(last_run_at)
@@ -108,6 +108,18 @@ def self.time_to_recur(last_run_at)
 end
 ```
 
+Recently added is the new jobs configuration. This adds two major new benefits. Firstly this will allow you to define jobs that are allow to run in multiple instances. Say for example that there should always be two instances of a given job running. This can now be defined using the following configuration:
+
+```ruby
+ScheduledJob.configure do |config|
+  config.jobs = {
+    MyAwesomeParallelJobClass => { count: 2 }
+  }
+end
+```
+
+This lets scheduled job know that it is OK to have two pending job instances for MyAwesomeParallelJobClass in the delayed job table. Additionally by using this configuration you also get access to the new reschedule rake task for free. ScheduledJob now adds `rake jobs:reschedule`. This will loop through your jobs configuration and automatically call schedule job up to the number of times you intend the jobs pending. This is useful for heavy users of scheduled job to "prime" your database with your recurring jobs. Note you can still add jobs to this configuration that you do not want any instances of by setting the count to 0. This is useful if you are looking to access all classes you have that you have registered with scheduled job.
+
 There are also callbacks that are available using ScheduledJob. These allow you to hook into the scheduling life cycle. Also note that as this uses DelayedJob under the hood all of the delayed job callbacks are still available for use.
 
 These can be defined when configuring the gem for you application on the configure block:
@@ -126,7 +138,7 @@ config.before_callback = -> (job, scheduled_job) do
 end
 ```
 
-The success_callback is called on sucessful completion of the job and is also passed the delayed job object and the scheduled job instance.
+The success_callback is called on successful completion of the job and is also passed the delayed job object and the scheduled job instance.
 
 ```ruby
 config.success_callback = -> (job, _) do
@@ -134,7 +146,7 @@ config.success_callback = -> (job, _) do
 end
 ```
 
-Then there is the fast mode. This is checked prior to scheduling another run of your job e.g. after a job has completed. This allows you to override the scheduling logic and ask the job to run immediatly. This is passed the scheduled job class. This means you can have state stored elsewhere to change the scheduling without having to modify the code. This could be getting an array from a database for example:
+Then there is the fast mode. This is checked prior to scheduling another run of your job e.g. after a job has completed. This allows you to override the scheduling logic and ask the job to run immediately. This is passed the scheduled job class. This means you can have state stored elsewhere to change the scheduling without having to modify the code. This could be getting an array from a database for example:
 
 ```ruby
 config.fast_mode = -> (job) do

data/lib/scheduled_job.rb

@@ -5,6 +5,9 @@ require 'delayed_job_active_record'
 require File.dirname(__FILE__) + '/tasks/jobs.rb'
 
 module ScheduledJob
+  class ConfigError < StandardError
+  end
+
   class << self
     attr_writer :config
     def config
@@ -12,32 +15,43 @@ module ScheduledJob
     end
   end
 
+  def self.reschedule
+    config.jobs.each do |job, options|
+      options[:count].times do
+        job.schedule_job
+      end
+    end if config.jobs
+  end
+
   def self.logger
     self.config.logger
   end
 
   def self.configure
     yield(config)
+    validate_job_hash(config.jobs) if config.jobs
+  end
+
+  def self.validate_job_hash(jobs)
+    jobs.each do |klass, options|
+      raise ConfigError.new("Jobs config found invalid class: #{klass}") unless klass.class == Class
+      raise ConfigError.new("Jobs config found invalid job count: #{options[:count]}") unless options[:count].to_i >= 0
+    end
   end
 
   class Config
-    attr_accessor :logger, :before_callback, :success_callback, :fast_mode
+    attr_accessor :logger, :before_callback, :success_callback, :fast_mode, :jobs
 
     def initialize
+      @jobs ||= {}
       @logger = Logger.new(STDOUT)
     end
   end
 
   def self.included(base)
-    @classes ||= []
-    @classes << base.name.constantize
     base.extend ScheduledJobClassMethods
   end
 
-  def self.classes
-    @classes
-  end
-
   def before(job)
     callback = ScheduledJob.config.before_callback
     callback.call(job, self) if callback
@@ -65,7 +79,7 @@ module ScheduledJob
     # This method should be called when scheduling a recurring job as it checks to ensure no
     # other instances of the job are already running.
     def schedule_job(job = nil)
-      unless job_exists?(job)
+      if can_schedule_job?(job)
         callback = ScheduledJob.config.fast_mode
         in_fast_mode = callback ? callback.call(self) : false
 
@@ -84,13 +98,20 @@ module ScheduledJob
       (base + Random.new.rand((-1 * random_delta)..random_delta)).minutes
     end
 
-    def job_exists?(job = nil)
+    def can_schedule_job?(job = nil)
       conditions = ['(handler like ? OR handler like ?) AND failed_at IS NULL', "%:#{self.name} %", "%:#{self.name}\n%"]
       unless job.blank?
         conditions[0] << " AND id != ?"
         conditions << job.id
       end
-      Delayed::Job.exists?(conditions)
+      job_count = Delayed::Job.where(conditions).count
+      intended_job_count = 1
+
+      if ScheduledJob.config.jobs && ScheduledJob.config.jobs[self.name]
+        intended_job_count = ScheduledJob.config.jobs[self.name][:count]
+      end
+
+      job_count < intended_job_count
     end
 
     def run_duration_threshold

data/lib/scheduled_job/version.rb

@@ -1,3 +1,3 @@
 module ScheduledJob
-  VERSION = "0.0.9"
+  VERSION = "0.1.0"
 end

data/lib/tasks/jobs.rb

@@ -5,20 +5,10 @@ module ScheduledJob
     include Rake::DSL if defined? Rake::DSL
 
     def install_tasks
-      def check_schedule_job(job)
-        if job.respond_to?(:time_to_recur)
-          job.schedule_job
-        else
-          job.descendants.each { |j| check_schedule_job(j) }
-        end
-      end
-
       namespace:jobs do
         desc "Will schedule all scheduled jobs"
         task :reschedule => :environment do
-          ScheduledJob.classes.each do |job|
-            check_schedule_job(job)
-          end
+          ScheduledJob.reschedule
         end
       end
     end

data/spec/lib/scheduled_job_spec.rb

@@ -20,6 +20,7 @@ class Test < UnderTest
 end
 
 describe ScheduledJob do
+  before { ScheduledJob.configure { |config| config.jobs = nil } }
 
   let(:under_test) { UnderTest.new }
 
@@ -37,8 +38,59 @@ describe ScheduledJob do
     end
   end
 
+  describe 'job config' do
+    it 'takes a jobs hash config' do
+      expect {
+        ScheduledJob.configure do |config|
+          config.jobs = {
+            UnderTest => { count: 1 }
+          }
+        end
+      }.not_to raise_error
+    end
+
+    context 'validates the job hash' do
+      it 'detects an bad job class' do
+        expect {
+          ScheduledJob.configure do |config|
+            config.jobs = {
+              'UnderTest' => { count: 1 }
+            }
+          end
+        }.to raise_error(ScheduledJob::ConfigError)
+      end
+
+      it 'detects a bad job count' do
+        expect {
+          ScheduledJob.configure do |config|
+            config.jobs = {
+              UnderTest => { count: -1 }
+            }
+          end
+        }.to raise_error(ScheduledJob::ConfigError)
+      end
+    end
+  end
+
+  describe 'reschedule' do
+    before do
+      ScheduledJob.configure do |config|
+        config.jobs = {
+          UnderTest => { count: 1 },
+          Test      => { count: 5 }
+        }
+      end
+    end
+
+    it 'calls reschedule on all config jobs up to the job count limit' do
+      expect(UnderTest).to receive(:schedule_job).once
+      expect(Test).to receive(:schedule_job).exactly(5).times
+      ScheduledJob.reschedule
+    end
+  end
+
   describe 'fast mode' do
-    before { expect(Delayed::Job).to receive(:exists?).and_return(false) }
+    before { expect(Delayed::Job).to receive(:where).and_return([]) }
 
     context 'when the job is not in run fast mode' do
       it 'uses the value from time to recur' do
@@ -121,7 +173,7 @@ describe ScheduledJob do
     allow(job).to receive(:id) { 4 }
     instance = double("instance")
     allow(UnderTest).to receive(:new) { instance }
-    expect(Delayed::Job).to receive(:exists?).and_return(false)
+    expect(Delayed::Job).to receive(:where).and_return([])
     expect(Delayed::Job).to receive(:enqueue).with(instance, run_at: "time to recur", queue: "TESTING")
     UnderTest.schedule_job job
   end
@@ -136,7 +188,7 @@ describe ScheduledJob do
     dummy_job = double("job")
     allow(dummy_job).to receive(:id)
     expect(dummy_job).to receive(:update_attributes!)
-    expect(Delayed::Job).to receive(:exists?).twice.and_return(false)
+    expect(Delayed::Job).to receive(:where).twice.and_return([])
     expect(Delayed::Job).to receive(:enqueue).exactly(2).times
     UnderTest.schedule_job
     under_test.failure(dummy_job)

data/spec/spec_helper.rb

@@ -1,3 +1,4 @@
+require 'pry'
 require 'simplecov'
 SimpleCov.start
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scheduled_job
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors:
 - CallumD
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-02 00:00:00.000000000 Z
+date: 2015-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: delayed_job