delayed_cron_job 0.7.2 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2b6628291d42c1bc4beef0cb884fb06474d5fea7
-  data.tar.gz: 3676a138edd3bece7b144579d4c013e0311b40bb
+SHA256:
+  metadata.gz: 853453d17f852e33afef72373ceec5a6fe462679272e5aa8a2cee37bccf26f3b
+  data.tar.gz: e88869f8b206ad9acd3214eb63ee4366e61c8113fc29084e8d8edaf1fd85db22
 SHA512:
-  metadata.gz: 3b4856da97ea1a3f57d085f4df9bace1322d6d02ebb7835a50ddf64c469bbcd30c15a93f80d906a78955b6e6e743f5ccf2b02f3f7628245e410e5b377f8c33d9
-  data.tar.gz: a8fb3f19c7096e2d800bef4a7824e6f8d7e28ea420eae2764664ca28f2c6c7b9729d1bbaa7957740a7277373a43d546f244d42d871041e4103c57dbe6ecf06dd
+  metadata.gz: b7bdef74835bd41fe795bc61889361bea65521b7c1771c6e2c29ef693fe15afeeafe74fecb0152a2be7aa40483578866ceec03711e24b71eafa7c66e454c05ad
+  data.tar.gz: 991d3d78e52d7932e96d99dacb0bd869bf5ac314fb0a2e89fa5b9d2c0063a63f595b22fad950bf72397003d3621bfabbe79e4e2863b41fee9bac410cb1043286

data/.gitignore

@@ -20,4 +20,5 @@ tmp
 *.o
 *.a
 mkmf.log
-.project
+.project
+file::memory:*

data/.travis.yml

@@ -1,7 +1,7 @@
 language: ruby
 
 rvm:
- - "2.3.0"
+ - "2.5.8"
 
 sudo: false
 

data/README.md

@@ -1,6 +1,6 @@
 # Delayed::Cron::Job
 
-{<img src="https://secure.travis-ci.org/codez/delayed_cron_job.png" />}[http://travis-ci.org/codez/delayed_cron_job]
+[![Build Status](https://travis-ci.org/codez/delayed_cron_job.svg)](https://travis-ci.org/codez/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.
@@ -28,16 +28,123 @@ There are no additional steps for `delayed_job_mongoid`.
 
 When enqueuing a job, simply pass the `cron` option, e.g.:
 
-    Delayed::Job.enqueue(MyRepeatedJob.new, cron: '15 */6 * * 1-5')
+```ruby
+Delayed::Job.enqueue(MyRepeatedJob.new, cron: '15 */6 * * 1-5')
+```
 
-Or, when using Active Job:
+Or, when using ActiveJob:
 
-    MyJob.set(cron: '*/5 * * * *').perform_later
+```ruby
+MyJob.set(cron: '*/5 * * * *').perform_later
+```
 
 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).
 
+## Scheduling
+
+Usually, you want to schedule all existing cron jobs when deploying the
+application. Using a common super class makes this simple.
+
+### Custom CronJob superclass
+
+`app/jobs/cron_job.rb`:
+
+```ruby
+# Default configuration in `app/jobs/application_job.rb`, or subclass
+# ActiveJob::Base .
+class CronJob < ApplicationJob
+
+  class_attribute :cron_expression
+
+  class << self
+
+    def schedule
+      set(cron: cron_expression).perform_later unless scheduled?
+    end
+
+    def remove
+      delayed_job.destroy if scheduled?
+    end
+
+    def scheduled?
+      delayed_job.present?
+    end
+
+    def delayed_job
+      Delayed::Job
+        .where('handler LIKE ?', "%job_class: #{name}%")
+        .first
+    end
+
+  end
+end
+```
+
+### Example Job inheriting from CronJob
+
+Then, an example job that triggers E-Mail-sending with default cron time at
+noon every day:
+
+`app/jobs/noon_job.rb`:
+
+```ruby
+
+# Note that it inherits from `CronJob`
+class NoonJob < CronJob
+  # set the (default) cron expression
+  self.cron_expression = '0 12 * * *'
+
+  # will enqueue the mailing delivery job
+  def perform
+    UserMailer.daily_notice(User.first).deliver_later
+  end
+end
+```
+
+### Scheduling "trigger"
+
+Jobs with a `cron` definition are rescheduled automatically only when a job
+instance finished its work. So there needs to be an initial scheduling of all
+cron jobs. If you do not want to do this manually (e.g. using `rails console`)
+or with your application logic, you can e.g. hook into the `rails db:*` rake
+tasks:
+
+`lib/tasks/jobs.rake`:
+
+```ruby
+namespace :db do
+  desc 'Schedule all cron jobs'
+  task :schedule_jobs => :environment do
+    # Need to load all jobs definitions in order to find subclasses
+    glob = Rails.root.join('app', 'jobs', '**', '*_job.rb')
+    Dir.glob(glob).each { |file| require file }
+    CronJob.subclasses.each { |job| job.schedule }
+  end
+end
+
+# invoke schedule_jobs automatically after every migration and schema load.
+%w(db:migrate db:schema:load).each do |task|
+  Rake::Task[task].enhance do
+    Rake::Task['db:schedule_jobs'].invoke
+  end
+end
+```
+
+Now, if you run `rails db:migrate`, `rails db:schema:load` or `rails
+db:schedule_jobs` all jobs inheriting from `CronJob` are scheduled.
+
+*If you are not using ActiveJob, the same approach may be used with minor
+adjustments.*
+
+### Changing the schedule
+
+Note that if you have a CronJob scheduled and change its `cron_expression` in
+its source file, you will have to remove any scheduled instances of the Job and
+reschedule it (e.g. with the snippet above: `rails db:migrate`). This is because
+the `cron_expression` is already persisted in the database (as `cron`).
+
 ## Details
 
 The initial `run_at` value is computed during the `#enqueue` method call.
@@ -71,4 +178,5 @@ jobs.
 ## License
 
 Delayed::Cron::Job is released under the terms of the MIT License.
-Copyright 2014-2017 Pascal Zumkehr. See LICENSE for further information.
+Copyright 2014-2020 Pascal Zumkehr. See [LICENSE](LICENSE) for further
+information.

data/lib/delayed_cron_job/backend/active_record/railtie.rb

@@ -0,0 +1,14 @@
+module DelayedCronJob
+  module Backend
+    module ActiveRecord
+      class Railtie < ::Rails::Railtie
+        config.after_initialize do
+          Delayed::Backend::ActiveRecord::Job.send(:include, DelayedCronJob::Backend::UpdatableCron)
+          if Delayed::Backend::ActiveRecord::Job.respond_to?(:attr_accessible)
+            Delayed::Backend::ActiveRecord::Job.attr_accessible(:cron)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/delayed_cron_job/backend/updatable_cron.rb

@@ -4,6 +4,7 @@ module DelayedCronJob
 
       def self.included(klass)
         klass.send(:before_save, :set_next_run_at, :if => :cron_changed?)
+        klass.attr_accessor :schedule_instead_of_destroy
       end
 
       def set_next_run_at
@@ -12,6 +13,17 @@ module DelayedCronJob
         end
       end
 
+      def destroy
+        super unless schedule_instead_of_destroy
+      end
+
+      def schedule_next_run
+        self.attempts += 1
+        unlock
+        set_next_run_at
+        save!
+      end
+
     end
   end
-end
+end

data/lib/delayed_cron_job/plugin.rb

@@ -17,7 +17,6 @@ module DelayedCronJob
           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)
@@ -26,31 +25,26 @@ module DelayedCronJob
 
       # 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
+        job.last_error = nil if cron?(job)
       end
 
-      # Update the cron expression from the database in case it was updated.
+      # Prevent destruction of cron jobs
       lifecycle.after(:invoke_job) do |job|
-        if cron?(job)
-          job.cron = job.class.where(:id => job.id).pluck(:cron).first
-        end
+        job.schedule_instead_of_destroy = true if cron?(job)
       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_job.save!
+        if cron?(job) && !job.destroyed?
+          job.cron = job.class.where(:id => job.id).pluck(:cron).first
+          if job.cron.present?
+            job.schedule_next_run
+          else
+            job.schedule_instead_of_destroy = false
+            job.destroy
+          end
         end
       end
     end
-
   end
 end

data/lib/delayed_cron_job/version.rb

@@ -1,3 +1,3 @@
 module DelayedCronJob
-  VERSION = '0.7.2'
+  VERSION = '0.7.4'
 end

data/lib/delayed_cron_job.rb

@@ -24,9 +24,15 @@ if defined?(Delayed::Backend::Mongoid)
 end
 
 if defined?(Delayed::Backend::ActiveRecord)
-  Delayed::Backend::ActiveRecord::Job.send(:include, DelayedCronJob::Backend::UpdatableCron)
-  if Delayed::Backend::ActiveRecord::Job.respond_to?(:attr_accessible)
-    Delayed::Backend::ActiveRecord::Job.attr_accessible(:cron)
+  if defined?(Rails::Railtie)
+    # Postpone initialization to railtie for correct order
+    require 'delayed_cron_job/backend/active_record/railtie'
+  else
+    # Do the same as in the railtie
+    Delayed::Backend::ActiveRecord::Job.send(:include, DelayedCronJob::Backend::UpdatableCron)
+    if Delayed::Backend::ActiveRecord::Job.respond_to?(:attr_accessible)
+      Delayed::Backend::ActiveRecord::Job.attr_accessible(:cron)
+    end
   end
 end
 

data/spec/delayed_cron_job_spec.rb

@@ -6,6 +6,16 @@ describe DelayedCronJob do
     def perform; end
   end
 
+  class DatabaseDisconnectPlugin < Delayed::Plugin
+
+    callbacks do |lifecycle|
+      lifecycle.after(:perform) do
+        ActiveRecord::Base.connection.disconnect!
+      end
+    end
+
+  end
+
   before { Delayed::Job.delete_all }
 
   let(:cron)    { '5 1 * * *' }
@@ -25,8 +35,8 @@ describe DelayedCronJob do
     end
 
     it 'enqueue fails with invalid cron' do
-      expect { Delayed::Job.enqueue(handler, cron: 'no valid cron') }.
-        to raise_error(ArgumentError)
+      expect { Delayed::Job.enqueue(handler, cron: 'no valid cron') }
+        .to raise_error(ArgumentError)
     end
 
     it 'schedules a new job after success' do
@@ -74,19 +84,16 @@ describe DelayedCronJob do
       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")
+      expect(j.last_error).to match('execution expired')
     end
 
-    it 'schedules new job after deserialization error' do
-      Delayed::Worker.max_run_time = 1.second
+    it 'does not schedule new job after deserialization error' do
       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")
+      expect(Delayed::Job.count).to eq(0)
     end
 
     it 'has empty last_error after success' do
@@ -116,7 +123,7 @@ describe DelayedCronJob do
         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"
+        pending 'This test only makes sense in non-UTC time zone'
       end
     end
 
@@ -168,6 +175,35 @@ describe DelayedCronJob do
       expect { worker.work_off }.to change { Delayed::Job.count }.by(-1)
     end
 
+    context 'when database connection is lost' do
+      around(:each) do |example|
+        Delayed::Worker.plugins.unshift DatabaseDisconnectPlugin
+        # hold onto a connection so the in-memory database isn't lost when disconnected
+        temp_connection = ActiveRecord::Base.connection_pool.checkout
+        example.run
+        ActiveRecord::Base.connection_pool.checkin temp_connection
+        Delayed::Worker.plugins.delete DatabaseDisconnectPlugin
+      end
+
+      it 'does not lose the job if database connection is lost' do
+        job.update_column(:run_at, now)
+        job.reload # adjusts granularity of run_at datetime
+
+        begin
+          worker.work_off
+        rescue StandardError
+          # Attempting to save the clone delayed_job will raise an exception due to the database connection being closed
+        end
+
+        ActiveRecord::Base.connection.reconnect!
+
+        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.attempts).to eq(0)
+      end
+    end
   end
 
   context 'without cron' do

data/spec/spec_helper.rb

@@ -23,7 +23,7 @@ ENV['RAILS_ENV'] = 'test'
 
 ActiveJob::Base.queue_adapter = :delayed_job
 
-ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => ':memory:'
+ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => 'file::memory:?cache=shared'
 ActiveRecord::Base.logger = Delayed::Worker.logger
 ActiveRecord::Migration.verbose = false
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delayed_cron_job
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.7.4
 platform: ruby
 authors:
 - Pascal Zumkehr
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-06-30 00:00:00.000000000 Z
+date: 2020-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: delayed_job
@@ -129,6 +129,7 @@ files:
 - lib/delayed_cron_job.rb
 - lib/delayed_cron_job/active_job/enqueuing.rb
 - lib/delayed_cron_job/active_job/queue_adapter.rb
+- lib/delayed_cron_job/backend/active_record/railtie.rb
 - lib/delayed_cron_job/backend/updatable_cron.rb
 - lib/delayed_cron_job/cronline.rb
 - lib/delayed_cron_job/plugin.rb
@@ -142,7 +143,7 @@ homepage: https://github.com/codez/delayed_cron_job
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -157,9 +158,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5.1
-signing_key: 
+rubygems_version: 3.0.6
+signing_key:
 specification_version: 4
 summary: An extension to Delayed::Job that allows you to set cron expressions for
   your jobs to run regularly.