clockwork 1.3.1 → 3.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 66489a780e645c6b88fe4fe8548faaa80615d85c
-  data.tar.gz: ad94d2f1a2f376d7f5931d177267b91ec6b69841
+SHA256:
+  metadata.gz: 4e5a8d520eb475e3eb5b3e75b3b175a4a66c3804584912afc9d4392c1d82f3d7
+  data.tar.gz: 558bc615e123ceaf146c2107b71202fef3eaf307215c93aa8f421826e25a8d4a
 SHA512:
-  metadata.gz: 9b1409ea965916002991e9fd1a38d2453350994d027aa9b114a7f4feee4edb1a902ac07076c691d84e462fc9b697fe13989858f524184311d44d3717c7887aba
-  data.tar.gz: 085f2739c059e90b8ea5875c0fb9b2eb161a7e09114cdd5db9a116a171fb5615db066278e65bfd641b78b1bac4cd77255438e8c27d94679d26bda66d4e2aa518
+  metadata.gz: d60240815eee8a5001004f854ccfd1fe94f01023ca5099799100bcc04a99ae982bc96f14b746b4965c4afc2aba77d2138ebae96c41da075bb7b8c4f15b863493
+  data.tar.gz: 4beb2d7f2cd09940e9159e5d4e1d1e62db2268f82b75ff86c344e7b11076a2e6d57865039fe19c361208c1fee8e5af8c3f72657880f6183107e8f90f33129e47

data/.github/workflows/tests.yml

@@ -0,0 +1,36 @@
+name: Tests
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby: [ "2.7", "3.0", "3.1", "3.2", jruby ]
+        active_support: [ "6.0", "7.0" ]
+        exclude:
+          - ruby: "3.0"
+            active_support: "6.0"
+          - ruby: "3.1"
+            active_support: "6.0"
+          - ruby: "3.2"
+            active_support: "6.0"
+    name: Ruby ${{ matrix.ruby }} - ActiveSupport ${{ matrix.active_support }}
+    env:
+      ACTIVE_SUPPORT_VERSION: ${{ matrix.active_support }}
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - name: Run Tests
+        env:
+          RUBYOPT: "-W:deprecated" # Show Ruby's deprecation warnings
+        run: |
+          bundle exec rake

data/CHANGELOG.md

@@ -0,0 +1,28 @@
+## 3.0.2 ##
+
+* Fixing clockworkd on Ruby 3.2 (a73a9d5)
+
+## 3.0.1 ##
+
+* Notify error using error handler if configured (49075c2)
+
+## 3.0.0 ##
+
+* BREAKING CHANGE: drop Rubinius support
+* add Ruby 3.0 support (65d71f)
+* fix a bug with OpenStruct (15eb030)
+* allow `:skip_first_run` in database events (429bc0a)
+* add rescue to prevent hung up by exception (cc1b7c9)
+* fix CI errors (16b4e19 & e4480ea)
+* fix a compatibility bug with Rails 7 (5907bc7)
+* Add "Finished" log with duration and error summary (66419ab)
+
+## 2.0.4 ##
+
+*   Reverts the breaking changes in PR #18 that went out in patch 2.0.3
+
+    *Javier Julio*
+
+## 2.0.3 (February 15, 2018) ##
+
+*   [See the version release](https://github.com/Rykian/clockwork/releases) for the commits that were included.

data/Gemfile

@@ -1,3 +1,8 @@
 source 'https://rubygems.org'
 
 gemspec
+
+rails_version = ENV.fetch("ACTIVE_SUPPORT_VERSION", "7.0")
+
+gem "activesupport", "~> #{rails_version}"
+gem "minitest", "~> 5.0"

data/README.md

@@ -1,8 +1,8 @@
-Clockwork - a clock process to replace cron [![Build Status](https://secure.travis-ci.org/tomykaira/clockwork.png?branch=master)](http://travis-ci.org/tomykaira/clockwork) [![Dependency Status](https://gemnasium.com/tomykaira/clockwork.png)](https://gemnasium.com/tomykaira/clockwork)
+Clockwork - a clock process to replace cron [![Build Status](https://api.travis-ci.com/Rykian/clockwork.svg?branch=master)](https://travis-ci.org/Rykian/clockwork)
 ===========================================
 
 Cron is non-ideal for running scheduled application tasks, especially in an app
-deployed to multiple machines.  [More details.](http://adam.heroku.com/past/2010/4/13/rethinking_cron/)
+deployed to multiple machines.  [More details.](http://adam.herokuapp.com/past/2010/4/13/rethinking_cron/)
 
 Clockwork is a cron replacement.  It runs as a lightweight, long-running Ruby
 process which sits alongside your web processes (Mongrel/Thin) and your worker
@@ -18,6 +18,8 @@ Create clock.rb:
 
 ```ruby
 require 'clockwork'
+require 'active_support/time' # Allow numeric durations (eg: 1.minutes)
+
 module Clockwork
   handler do |job|
     puts "Running #{job}"
@@ -58,8 +60,8 @@ Quickstart for Heroku
 
 Clockwork fits well with heroku's cedar stack.
 
-Consider to use [clockwork-init.sh](https://gist.github.com/1312172) to create
-a new project for heroku.
+Consider using [clockwork-init.sh](https://gist.github.com/tomykaira/1312172) to create
+a new project for Heroku.
 
 Use with queueing
 -----------------
@@ -69,8 +71,8 @@ to do the work.  It avoids locking by running as a single process, but this
 makes it impossible to parallelize.  For doing the work, you should be using a
 job queueing system, such as
 [Delayed Job](http://www.therailsway.com/2009/7/22/do-it-later-with-delayed-job),
-[Beanstalk/Stalker](http://adam.heroku.com/past/2010/4/24/beanstalk_a_simple_and_fast_queueing_backend/),
-[RabbitMQ/Minion](http://adam.heroku.com/past/2009/9/28/background_jobs_with_rabbitmq_and_minion/),
+[Beanstalk/Stalker](http://adam.herokuapp.com/past/2010/4/24/beanstalk_a_simple_and_fast_queueing_backend/),
+[RabbitMQ/Minion](http://adam.herokuapp.com/past/2009/9/28/background_jobs_with_rabbitmq_and_minion/),
 [Resque](http://github.com/blog/542-introducing-resque), or
 [Sidekiq](https://github.com/mperham/sidekiq).  This design allows a
 simple clock process with no locks, but also offers near infinite horizontal
@@ -80,6 +82,7 @@ For example, if you're using Beanstalk/Stalker:
 
 ```ruby
 require 'stalker'
+require 'active_support/time'
 
 module Clockwork
   handler { |job| Stalker.enqueue(job) }
@@ -92,7 +95,7 @@ end
 Using a queueing system which doesn't require that your full application be
 loaded is preferable, because the clock process can keep a tiny memory
 footprint.  If you're using DJ or Resque, however, you can go ahead and load
-your full application enviroment, and use per-event blocks to call DJ or Resque
+your full application environment, and use per-event blocks to call DJ or Resque
 enqueue methods.  For example, with DJ/Rails:
 
 ```ruby
@@ -142,27 +145,33 @@ module Clockwork
 end
 ```
 
-This tells clockwork to fetch all `ClockworkDatabaseEvent` instances from the database, creating an internal clockwork event for each one, configured based on the instance's `frequency`, `at` and optionally `name` and `tz` methods. It also says to reload the events from the database every `1.minute`; we need pick up any changes in the database frequently (choose a sensible reload frequency by changing the `every:` option).
+This tells clockwork to fetch all `ClockworkDatabaseEvent` instances from the database, and create an internal clockwork event for each one. Each clockwork event will be configured based on the instance's `frequency` and, optionally, its `at`, `if?`, `ignored_attributes`, `name`, and, `tz` methods. The code above also says to reload the events from the database every `1.minute`; we need pick up any changes in the database frequently (choose a sensible reload frequency by changing the `every:` option).
 
-When one of the events is ready to be run (based on it's `frequency`, `at` and possible `tz` methods), clockwork arranges for the block passed to `sync_database_events` to be run. The above example shows how you could use either DelayedJob or Sidekiq to simply kick off a worker job. This approach is good because the ideal is to use clockwork as a simple scheduler, and avoid making it carry out any long-running tasks.
+When one of the events is ready to be run (based on it's `frequency`, and possible `at`, `if?`, `ignored attributes`, and `tz` methods), clockwork arranges for the block passed to `sync_database_events` to be run. The above example shows how you could use either DelayedJob or Sidekiq to kick off a worker job. This approach is good because the ideal is to use clockwork as a simple scheduler, and avoid making it carry out any long-running tasks.
 
 ### Your Model Classes
 
 `ActiveRecord` models are a perfect candidate for the model class. Having said that, the only requirements are:
 
-  1. the class responds to `all` returning an array of instances from the database
+1. the class responds to `all` returning an array of instances from the database
+
+2. the instances returned respond to:
+   - `id` returning a unique identifier (this is needed to track changes to event settings)
+   - `frequency` returning the how frequently (in seconds) the database event should be run
+
+   - `attributes` returning a hash of [attribute name] => [attribute value] values (or really anything that we can use store on registering the event, and then compare again to see if the state has changed later)
 
-  2. the instances returned respond to:
+   - `at` *(optional)* return any acceptable clockwork `:at` string
 
-    - `id` returning a unique identifier (this is needed to track changes to event settings)
+   - `name` *(optional)* returning the name for the event (used to identify it in the Clockwork output)
 
-    - `frequency` returning the how frequently (in seconds) the database event should be run
+   - `if?`*(optional)*  returning either true or false, depending on whether the database event should run at the given time (this method will be passed the time as a parameter, much like the standard clockwork `:if`)
 
-    - `at` return nil or `''` if not using `:at`, or otherwise any acceptable clockwork `:at` string
+   - `ignored_attributes` *(optional)* returning an array of model attributes (as symbols) to ignore when determining whether the database event has been modified since our last run
 
-    - (optionally) `name` returning the name for the event (used to identify it in the Clcockwork output)
+   - `tz` *(optional)* returning the timezone to use (default is the local timezone)
 
-    - (optionally) `tz` returning the timezone to use (default is the local timezone)
+   - `skip_first_run` *(optional)* self explanatory, see [dedicated section](#skip_first_run)
 
 #### Example Setup
 
@@ -220,6 +229,50 @@ end
 ...
 ```
 
+#### Example use of `if?`
+
+Database events support the ability to run events if certain conditions are met. This can be used to only run events on a given day, week, or month, or really any criteria you could conceive. Best of all, these criteria e.g. which day to
+run it on can be attributes on your Model, and therefore change dynamically as you change the Model in the database.
+
+So for example, if you had a Model that had a `day` and `month` integer attribute, you could specify that the Database event should only run on a particular day of a particular month as follows:
+
+```ruby
+# app/models/clockwork_database_event.rb
+class ClockworkDatabaseEvent < ActiveRecord::Base
+
+  ...
+
+  def if?(time)
+    time.day == day && time.month == month
+  end
+
+  ...
+end
+```
+
+#### Example use of `ignored_attributes`
+
+Clockwork compares all attributes of the model between runs to determine if the model has changed, and if it has, it runs the event if all other conditions are met.
+
+However, in certain cases, you may want to store additional attributes in your model that you don't want to affect whether a database event is executed prior to its next interval.
+
+So for example, you may update an attribute of your model named `last_scheduled_at` on each run to track the last time it was successfully scheduled. You can tell Clockwork to ignore that attribute in its comparison as follows:
+
+```ruby
+# app/models/clockwork_database_event.rb
+class ClockworkDatabaseEvent < ActiveRecord::Base
+
+  ...
+
+  def ignored_attributes
+    [ :last_scheduled_at ]
+  end
+
+  ...
+end
+```
+
+
 Event Parameters
 ----------
 
@@ -279,7 +332,8 @@ If this is a problem, please use the `:thread` option to prevent the long runnin
 ```ruby
 every(1.day, 'reminders.send', :at => '00:00', :tz => 'UTC')
 # Runs the job each day at midnight, UTC.
-# The value for :tz can be anything supported by [TZInfo](http://tzinfo.rubyforge.org/)
+# The value for :tz can be anything supported by [TZInfo](https://github.com/tzinfo/tzinfo)
+# Using the 'tzinfo' gem, run TZInfo::Timezone.all_identifiers to get a list of acceptable identifiers.
 ```
 
 ### :if
@@ -315,6 +369,19 @@ Clockwork.every(1.day, 'run.me.in.new.thread', :thread => true)
 
 If a job is long-running or IO-intensive, this option helps keep the clock precise.
 
+### :skip_first_run
+
+Normally, a clockwork process that is defined to run in a specified period will run at startup.
+This is sometimes undesired behaviour, if the action being run relies on other processes booting which may be slower than clock.
+To avoid this problem, `:skip_first_run` can be used.
+
+```ruby
+Clockwork.every(5.minutes, 'myjob', :skip_first_run => true)
+```
+
+The above job will not run at initial boot, and instead run every 5 minutes after boot.
+
+
 Configuration
 -----------------------
 
@@ -331,7 +398,6 @@ Clockwork wakes up once a second and performs its duties. To change the number o
 sleeps, set the `sleep_timeout` configuration option as shown below in the example.
 
 From 1.1.0, Clockwork does not accept `sleep_timeout` less than 1 seconds.
-This restriction is introduced to solve more severe bug [#135](https://github.com/tomykaira/clockwork/pull/135).
 
 ### :tz
 
@@ -437,8 +503,8 @@ every(1.day, 'check.leap.year') do
 end
 ```
 
-In addition, Clockwork also supports `:before_tick` and `after_tick` callbacks.
-They are optional, and run every tick (a tick being whatever your `:sleep_timeout`
+In addition, Clockwork also supports `:before_tick`, `:after_tick`, `:before_run`, and `:after_run` callbacks.
+All callbacks are optional. All `before` callbacks must return a truthy value otherwise the job will not run. The `tick` callbacks run every tick (a tick being whatever your `:sleep_timeout`
 is set to, default is 1 second):
 
 ```ruby
@@ -449,6 +515,14 @@ end
 on(:after_tick) do
   puts "tock"
 end
+
+on(:before_run) do |event, t|
+  puts "job_started: #{event}"
+end
+
+on(:after_run) do |event, t|
+  puts "job_finished: #{event}"
+end
 ```
 
 Finally, you can use tasks synchronised from a database as described in detail above:
@@ -490,10 +564,17 @@ clockworkd -c YOUR_CLOCK.rb start
 
 For more details, you can run `clockworkd -h`.
 
+Integration Testing
+-------------------
+
+You could take a look at:
+* [clockwork-mocks](https://github.com/dpoetzsch/clockwork-mocks) that helps with running scheduled tasks during integration testing.
+* [clockwork-test](https://github.com/kevin-j-m/clockwork-test) which ensures that tasks are triggered at the right time
+
 Issues and Pull requests
 ------------------------
 
-If you find a bug, please create an issue - [Issues · tomykaira/clockwork](https://github.com/tomykaira/clockwork/issues).
+If you find a bug, please create an issue - [Issues · Rykian/clockwork](https://github.com/Rykian/clockwork/issues).
 
 For a bug fix or a feature request, please send a pull-request.
 Do not forget to add tests to show how your feature works, or what bug is fixed.
@@ -509,8 +590,8 @@ Use cases
 
 Feel free to add your idea or experience and send a pull-request.
 
-- [Sending errors to Airbrake](https://github.com/tomykaira/clockwork/issues/58)
-- [Read events from a database](https://github.com/tomykaira/clockwork/issues/25)
+- Sending errors to Airbrake
+- Read events from a database
 
 Meta
 ----
@@ -525,4 +606,4 @@ Patches contributed by Mark McGranaghan and Lukáš Konarovský
 
 Released under the MIT License: http://www.opensource.org/licenses/mit-license.php
 
-http://github.com/tomykaira/clockwork
+https://github.com/Rykian/clockwork

data/bin/clockwork

@@ -4,16 +4,11 @@ STDERR.sync = STDOUT.sync = true
 
 require 'clockwork'
 
-usage = 'clockwork <clock.rb>'
+usage = 'Usage: clockwork <clock.rb>'
 file = ARGV.shift or abort usage
 
 file = "./#{file}" unless file.match(/^[\/.]/)
 
 require file
 
-trap('INT') do
-  puts "\rExiting"
-  exit
-end
-
 Clockwork::run

data/bin/clockworkd

@@ -4,6 +4,7 @@ STDERR.sync = STDOUT.sync = true
 
 require 'clockwork'
 require 'optparse'
+require 'pathname'
 
 begin
   require 'daemons'
@@ -45,7 +46,7 @@ opts = OptionParser.new do |opts|
   end
   opts.on('-c', '--clock=FILE',"Clock .rb file. Default is #{@options[:file]}.") do |clock_file|
     @options[:file] = clock_file
-    @options[:file] = "./#{@options[:file]}" unless @options[:file].match(/^[\/.]/)
+    @options[:file] = "./#{@options[:file]}" unless Pathname.new(@options[:file]).absolute?
     @options[:file] = File.expand_path(@options[:file])
   end
   opts.on('-d', '--dir=DIR', 'Directory to change to once the process starts') do |dir|
@@ -62,7 +63,7 @@ def optparser_abort(opts,message)
 end
 
 optparser_abort opts, "ERROR: --clock=FILE is required." unless @options[:file]
-optparser_abort opts, "ERROR: clock file #{@options[:file]} does not exist." unless File.exists?(@options[:file])
+optparser_abort opts, "ERROR: clock file #{@options[:file]} does not exist." unless File.exist?(@options[:file])
 optparser_abort opts, "ERROR: File extension specified in --clock must be '.rb'" unless File.extname(@options[:file]) == ".rb"
 
 @options[:identifier]  ||= "#{File.basename(@options[:file],'.*')}"
@@ -70,8 +71,8 @@ process_name = "#{bin_basename}.#{@options[:identifier]}"
 
 @options[:log_dir] ||= @options[:pid_dir]
 
-Dir.mkdir(@options[:pid_dir]) unless File.exists?(@options[:pid_dir])
-Dir.mkdir(@options[:log_dir]) unless File.exists?(@options[:log_dir])
+Dir.mkdir(@options[:pid_dir]) unless File.exist?(@options[:pid_dir])
+Dir.mkdir(@options[:log_dir]) unless File.exist?(@options[:log_dir])
 
 puts "#{process_name}: pid file: #{File.expand_path(File.join(@options[:pid_dir],process_name + '.pid'))}"
 

data/clockwork.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "clockwork"
-  s.version = "1.3.1"
+  s.version = "3.0.2"
 
   s.authors = ["Adam Wiggins", "tomykaira"]
   s.license = 'MIT'
@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
   s.extra_rdoc_files = [
     "README.md"
   ]
-  s.homepage = "http://github.com/tomykaira/clockwork"
+  s.homepage = "http://github.com/Rykian/clockwork"
   s.summary = "A scheduler process to replace cron."
 
   s.files         = `git ls-files`.split($/)
@@ -20,9 +20,9 @@ Gem::Specification.new do |s|
   s.add_dependency(%q<tzinfo>)
   s.add_dependency(%q<activesupport>)
 
-  s.add_development_dependency "bundler", "~> 1.3"
   s.add_development_dependency "rake"
   s.add_development_dependency "daemons"
   s.add_development_dependency "minitest", "~> 5.8"
   s.add_development_dependency "mocha"
+  s.add_development_dependency "test-unit"
 end

data/lib/clockwork/database_events/event.rb

@@ -4,12 +4,13 @@ module Clockwork
 
     class Event < Clockwork::Event
 
-      attr_accessor :event_store, :at
+      attr_accessor :event_store, :model_attributes
 
-      def initialize(manager, period, job, block, event_store, options={})
+      def initialize(manager, period, job, block, event_store, model_attributes, options={})
         super(manager, period, job, block, options)
         @event_store = event_store
         @event_store.register(self, job)
+        @model_attributes = model_attributes
       end
 
       def name

data/lib/clockwork/database_events/event_collection.rb

@@ -14,9 +14,14 @@ module Clockwork
       def has_changed?(model)
         return true if event.nil?
 
-        (has_name? && name != model.name) ||
-          frequency != model.frequency ||
-            ats != model_ats(model)
+        ignored_attributes = model.ignored_attributes if model.respond_to?(:ignored_attributes)
+        ignored_attributes ||= []
+
+        model_attributes = model.attributes.select do |k, _|
+          not ignored_attributes.include?(k.to_sym)
+        end
+
+        event.model_attributes != model_attributes
       end
 
       def unregister
@@ -27,33 +32,12 @@ module Clockwork
 
       attr_reader :events, :manager
 
+      # All events in the same collection (for a model instance) are equivalent
+      # so we can use any of them. Only their @at variable will be different,
+      # but we don't care about that here.
       def event
         events.first
       end
-
-      def has_name?
-        event.job_has_name?
-      end
-
-      def name
-        event.name
-      end
-
-      def frequency
-        event.frequency
-      end
-
-      def ats
-        events.collect(&:at).compact
-      end
-
-      def model_ats(model)
-        at_strings_for(model).collect{|at| At.parse(at) }
-      end
-
-      def at_strings_for(model)
-        model.at.to_s.split(',').map(&:strip)
-      end
     end
   end
 end

data/lib/clockwork/database_events/event_store.rb

@@ -112,10 +112,20 @@ module Clockwork
         options = {
           :from_database => true,
           :synchronizer => self,
-          :at => at_strings_for(model)
+          :ignored_attributes => [],
         }
 
+        options[:at] = at_strings_for(model) if model.respond_to?(:at)
+        options[:if] = ->(time){ model.if?(time) } if model.respond_to?(:if?)
         options[:tz] = model.tz if model.respond_to?(:tz)
+        options[:ignored_attributes] = model.ignored_attributes if model.respond_to?(:ignored_attributes)
+        options[:skip_first_run] = model.skip_first_run if model.respond_to?(:skip_first_run)
+
+        # store the state of the model at time of registering so we can
+        # easily compare and determine if state has changed later
+        options[:model_attributes] = model.attributes.select do |k, v|
+          not options[:ignored_attributes].include?(k.to_sym)
+        end
 
         options
       end

data/lib/clockwork/database_events/manager.rb

@@ -10,7 +10,11 @@ module Clockwork
 
       def register(period, job, block, options)
         @events << if options[:from_database]
-          Clockwork::DatabaseEvents::Event.new(self, period, job, (block || handler), options.fetch(:synchronizer), options)
+          synchronizer = options.fetch(:synchronizer)
+          model_attributes = options.fetch(:model_attributes)
+
+          Clockwork::DatabaseEvents::Event.
+            new(self, period, job, (block || handler), synchronizer, model_attributes, options)
         else
           Clockwork::Event.new(self, period, job, block || handler, options)
         end

data/lib/clockwork/database_events/synchronizer.rb

@@ -1,5 +1,3 @@
-require_relative '../database_events'
-
 module Clockwork
 
   module DatabaseEvents

data/lib/clockwork/event.rb

@@ -8,11 +8,12 @@ module Clockwork
       @period = period
       @job = job
       @at = At.parse(options[:at])
-      @last = nil
       @block = block
       @if = options[:if]
       @thread = options.fetch(:thread, @manager.config[:thread])
       @timezone = options.fetch(:tz, @manager.config[:tz])
+      @skip_first_run = options[:skip_first_run]
+      @last = @skip_first_run ? convert_timezone(Time.now) : nil
     end
 
     def convert_timezone(t)
@@ -21,7 +22,10 @@ module Clockwork
 
     def run_now?(t)
       t = convert_timezone(t)
-      elapsed_ready(t) and (@at.nil? or @at.ready?(t)) and (@if.nil? or @if.call(t))
+      return false unless elapsed_ready?(t)
+      return false unless run_at?(t)
+      return false unless run_if?(t)
+      true
     end
 
     def thread?
@@ -51,16 +55,33 @@ module Clockwork
 
     private
     def execute
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      error = nil
+
       @block.call(@job, @last)
     rescue => e
+      error = e
       @manager.log_error e
       @manager.handle_error e
+    ensure
+      finish = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      duration = ((finish - start) * 1000).round # milliseconds
+
+      @manager.log "Finished '#{self}' duration_ms=#{duration} error=#{error.inspect}"
     end
 
-    def elapsed_ready(t)
+    def elapsed_ready?(t)
       @last.nil? || (t - @last.to_i).to_i >= @period
     end
 
+    def run_at?(t)
+      @at.nil? || @at.ready?(t)
+    end
+
+    def run_if?(t)
+      @if.nil? || @if.call(t)
+    end
+
     def validate_if_option(if_option)
       if if_option && !if_option.respond_to?(:call)
         raise ArgumentError.new(':if expects a callable object, but #{if_option} does not respond to call')

data/lib/clockwork/manager.rb

@@ -9,6 +9,9 @@ module Clockwork
       @callbacks = {}
       @config = default_configuration
       @handler = nil
+      @mutex = Mutex.new
+      @condvar = ConditionVariable.new
+      @finish = false
     end
 
     def thread_available?
@@ -34,7 +37,7 @@ module Clockwork
 
     def error_handler(&block)
       @error_handler = block if block_given?
-      @error_handler
+      @error_handler if instance_variable_defined?("@error_handler")
     end
 
     def on(event, options={}, &block)
@@ -60,10 +63,68 @@ module Clockwork
 
     def run
       log "Starting clock for #{@events.size} events: [ #{@events.map(&:to_s).join(' ')} ]"
-      loop do
-        tick
-        interval = config[:sleep_timeout] - Time.now.subsec + 0.001
-        sleep(interval) if interval > 0
+
+      sig_read, sig_write = IO.pipe
+
+      (%w[INT TERM HUP] & Signal.list.keys).each do |sig|
+        trap sig do
+          sig_write.puts(sig)
+        end
+      end
+
+      run_tick_loop
+
+      while io = IO.select([sig_read])
+        sig = io.first[0].gets.chomp
+        handle_signal(sig)
+      end
+    end
+
+    def handle_signal(sig)
+      logger.debug "Got #{sig} signal"
+      case sig
+      when 'INT'
+        shutdown
+      when 'TERM'
+        # Heroku sends TERM signal, and waits 10 seconds before exit
+        graceful_shutdown
+      when 'HUP'
+        graceful_shutdown
+      end
+    end
+
+    def shutdown
+      logger.info 'Shutting down'
+      stop_tick_loop
+      exit(0)
+    end
+
+    def graceful_shutdown
+      logger.info 'Gracefully shutting down'
+      stop_tick_loop
+      wait_tick_loop_finishes
+      exit(0)
+    end
+
+    def stop_tick_loop
+      @finish = true
+    end
+
+    def wait_tick_loop_finishes
+      @mutex.synchronize do # wait by synchronize
+        @condvar.signal
+      end
+    end
+
+    def run_tick_loop
+      Thread.new do
+        @mutex.synchronize do
+          until @finish
+            tick
+            interval = config[:sleep_timeout] - Time.now.subsec + 0.001
+            @condvar.wait(@mutex, interval) if interval > 0
+          end
+        end
       end
     end
 
@@ -81,6 +142,10 @@ module Clockwork
       events
     end
 
+    def logger
+      config[:logger]
+    end
+
     def log_error(e)
       config[:logger].error(e)
     end
@@ -95,7 +160,15 @@ module Clockwork
 
     private
     def events_to_run(t)
-      @events.select{ |event| event.run_now?(t) }
+      @events.select do |event|
+        begin
+          event.run_now?(t)
+        rescue => e
+          log_error(e)
+          handle_error(e)
+          false
+        end
+      end
     end
 
     def register(period, job, block, options)

data/lib/clockwork.rb

@@ -1,4 +1,5 @@
 require 'logger'
+require 'active_support'
 require 'active_support/time'
 
 require 'clockwork/at'

data/test/at_test.rb

@@ -1,6 +1,6 @@
 require File.expand_path('../../lib/clockwork', __FILE__)
 require "minitest/autorun"
-require 'mocha/setup'
+require 'mocha/minitest'
 require 'time'
 require 'active_support/time'
 

data/test/clockwork_test.rb

@@ -1,6 +1,6 @@
 require File.expand_path('../../lib/clockwork', __FILE__)
 require 'minitest/autorun'
-require 'mocha/setup'
+require 'mocha/minitest'
 
 describe Clockwork do
   before do
@@ -9,6 +9,7 @@ describe Clockwork do
       config[:sleep_timeout] = 0
       config[:logger] = Logger.new(@log_output)
     end
+    IO.stubs(:select)
   end
 
   after do
@@ -21,11 +22,12 @@ describe Clockwork do
       run = job == 'myjob'
     end
     Clockwork.every(1.minute, 'myjob')
-    Clockwork.manager.expects(:loop).yields.then.returns
+    Clockwork.manager.stubs(:run_tick_loop).returns(Clockwork.manager.tick)
     Clockwork.run
 
     assert run
     assert @log_output.string.include?('Triggering')
+    assert @log_output.string.include?('Finished')
   end
 
   it 'should log event correctly' do
@@ -34,10 +36,25 @@ describe Clockwork do
       run = job == 'an event'
     end
     Clockwork.every(1.minute, 'an event')
-    Clockwork.manager.expects(:loop).yields.then.returns
+    Clockwork.manager.stubs(:run_tick_loop).returns(Clockwork.manager.tick)
     Clockwork.run
     assert run
     assert @log_output.string.include?("Triggering 'an event'")
+    assert_match(/Finished 'an event' duration_ms=\d+ error=nil/, @log_output.string)
+  end
+
+  it 'should log exceptions' do
+    run = false
+    Clockwork.handler do |job|
+      run = job == 'an event'
+      raise 'boom'
+    end
+    Clockwork.every(1.minute, 'an event')
+    Clockwork.manager.stubs(:run_tick_loop).returns(Clockwork.manager.tick)
+    Clockwork.run
+    assert run
+    assert @log_output.string.include?("Triggering 'an event'")
+    assert_match(/Finished 'an event' duration_ms=\d+ error=#<RuntimeError: boom>/, @log_output.string)
   end
 
   it 'should pass event without modification to handler' do
@@ -47,7 +64,7 @@ describe Clockwork do
       run = job == event_object
     end
     Clockwork.every(1.minute, event_object)
-    Clockwork.manager.expects(:loop).yields.then.returns
+    Clockwork.manager.stubs(:run_tick_loop).returns(Clockwork.manager.tick)
     Clockwork.run
     assert run
   end
@@ -59,14 +76,14 @@ describe Clockwork do
       config[:sleep_timeout] = 0
       config[:logger] = Logger.new(@log_output)
     end
-    Clockwork.manager.expects(:loop).yields.then.returns
+    Clockwork.manager.stubs(:run_tick_loop).returns(Clockwork.manager.tick)
     Clockwork.run
     assert @log_output.string.include?('0 events')
   end
 
   it 'should pass all arguments to every' do
     Clockwork.every(1.second, 'myjob', if: lambda { |_| false }) {  }
-    Clockwork.manager.expects(:loop).yields.then.returns
+    Clockwork.manager.stubs(:run_tick_loop).returns(Clockwork.manager.tick)
     Clockwork.run
     assert @log_output.string.include?('1 events')
     assert !@log_output.string.include?('Triggering')
@@ -77,7 +94,7 @@ describe Clockwork do
     module ::Clockwork
       every(1.second, 'myjob') { $called = true }
     end
-    Clockwork.manager.expects(:loop).yields.then.returns
+    Clockwork.manager.stubs(:run_tick_loop).returns(Clockwork.manager.tick)
     Clockwork.run
     assert $called
   end

data/test/database_events/event_store_test.rb

@@ -1,6 +1,7 @@
 require "minitest/autorun"
 require 'clockwork/database_events/event_store'
 require 'clockwork/database_events/event_collection'
+require 'ostruct'
 
 describe Clockwork::DatabaseEvents::EventStore do
 

data/test/database_events/support/active_record_fake.rb

@@ -23,9 +23,13 @@ module ActiveRecordFake
     set_attribute_values_from_options options
   end
 
+  def attributes
+    Hash[instance_variables.map { |name| [name, instance_variable_get(name)] } ]
+  end
+
   module ClassMethods
-    def create *args
-      new *args
+    def create(*args)
+      new(*args)
     end
     
     def delete_all

data/test/database_events/synchronizer_test.rb

@@ -1,5 +1,5 @@
 require "minitest/autorun"
-require 'mocha/setup'
+require 'mocha/minitest'
 require 'time'
 require 'active_support/time'
 
@@ -10,8 +10,6 @@ require_relative 'test_helpers'
 describe Clockwork::DatabaseEvents::Synchronizer do
   before do
     @now = Time.now
-    DatabaseEventModel.delete_all
-    DatabaseEventModel2.delete_all
 
     Clockwork.manager = @manager = Clockwork::DatabaseEvents::Manager.new
     class << @manager
@@ -21,6 +19,9 @@ describe Clockwork::DatabaseEvents::Synchronizer do
 
   after do
     Clockwork.clear!
+    DatabaseEventModel.delete_all
+    DatabaseEventModel2.delete_all
+    DatabaseEventModelWithIf.delete_all
   end
 
   describe "setup" do
@@ -254,6 +255,37 @@ describe Clockwork::DatabaseEvents::Synchronizer do
       end
     end
 
+    describe "with model that responds to `if?`" do
+
+      before do
+        @events_run = []
+      end
+
+      describe "when model.if? is true" do
+        it 'runs' do
+          DatabaseEventModelWithIf.create(:if_state => true, :frequency => 10)
+          setup_sync(model: DatabaseEventModelWithIf, :every => 1.minute, :events_run => @events_run)
+
+          tick_at(@now, :and_every_second_for => 9.seconds)
+
+          assert_equal 1, @events_run.length
+        end
+      end
+
+      describe "when model.if? is false" do
+        it 'does not run' do
+          DatabaseEventModelWithIf.create(:if_state => false, :frequency => 10, :name => 'model with if?')
+          setup_sync(model: DatabaseEventModelWithIf, :every => 1.minute, :events_run => @events_run)
+
+          tick_at(@now, :and_every_second_for => 1.minute)
+
+          # require 'byebug'
+          # byebug if events_run.length > 0
+          assert_equal 0, @events_run.length
+        end
+      end
+    end
+
     describe "with task that responds to `tz`" do
       before do
         @events_run = []

data/test/database_events/test_helpers.rb

@@ -36,23 +36,60 @@ end
 
 class DatabaseEventModel
   include ActiveRecordFake
-  attr_accessor :name, :frequency, :at, :tz
+  attr_accessor :frequency, :at, :tz
 
   def name
-    @name || "#{self.class}:#{id}"
+    if instance_variable_defined?("@name")
+      @name
+    else
+      "#{self.class}:#{id}"
+    end
+  end
+
+  def name=(name)
+    @name = name
   end
 end
 
 class DatabaseEventModel2
   include ActiveRecordFake
-  attr_accessor :name, :frequency, :at, :tz
+  attr_accessor :frequency, :at, :tz
 
   def name
-    @name || "#{self.class}:#{id}"
+    if instance_variable_defined?("@name")
+      @name
+    else
+      "#{self.class}:#{id}"
+    end
+  end
+
+  def name=(name)
+    @name = name
   end
 end
 
 class DatabaseEventModelWithoutName
   include ActiveRecordFake
   attr_accessor :frequency, :at
+end
+
+class DatabaseEventModelWithIf
+  include ActiveRecordFake
+  attr_accessor :frequency, :at, :tz, :if_state
+
+  def name
+    if instance_variable_defined?("@name")
+      @name
+    else
+      "#{self.class}:#{id}"
+    end
+  end
+
+  def name=(name)
+    @name = name
+  end
+
+  def if?(time)
+    @if_state
+  end
 end

data/test/event_test.rb

@@ -34,4 +34,41 @@ describe Clockwork::Event do
       end
     end
   end
+
+  describe '#run_now?' do
+    before do
+      @manager = Class.new
+      @manager.stubs(:config).returns({})
+    end
+
+    describe 'event skip_first_run option set to true' do
+      it 'returns false on first attempt' do
+        event = Clockwork::Event.new(@manager, 1, nil, nil, :skip_first_run => true)
+        assert_equal false, event.run_now?(Time.now)
+      end
+
+      it 'returns true on subsequent attempts' do
+        event = Clockwork::Event.new(@manager, 1, nil, nil, :skip_first_run => true)
+        # first run
+        event.run_now?(Time.now)
+
+        # second run
+        assert_equal true, event.run_now?(Time.now + 1)
+      end
+    end
+
+    describe 'event skip_first_run option not set' do
+      it 'returns true on first attempt' do
+        event = Clockwork::Event.new(@manager, 1, nil, nil)
+        assert_equal true, event.run_now?(Time.now + 1)
+      end
+    end
+
+    describe 'event skip_first_run option set to false' do
+      it 'returns true on first attempt' do
+        event = Clockwork::Event.new(@manager, 1, nil, nil, :skip_first_run => false)
+        assert_equal true, event.run_now?(Time.now)
+      end
+    end
+  end
 end

data/test/manager_test.rb

@@ -1,6 +1,6 @@
 require File.expand_path('../../lib/clockwork', __FILE__)
 require "minitest/autorun"
-require 'mocha/setup'
+require 'mocha/minitest'
 require 'time'
 require 'active_support/time'
 

data/test/samples/signal_test.rb

@@ -0,0 +1,20 @@
+require 'clockwork'
+require 'active_support/time'
+
+module Clockwork
+  LOGFILE = File.expand_path('../../tmp/signal_test.log', __FILE__)
+
+  handler do |job|
+    File.write(LOGFILE, 'start')
+    sleep 0.1
+    File.write(LOGFILE, 'done')
+  end
+
+  configure do |config|
+    config[:sleep_timeout] = 0
+    config[:logger] = Logger.new(StringIO.new)
+  end
+
+  every(1.seconds, 'run.me.every.1.seconds')
+end
+

data/test/signal_test.rb

@@ -0,0 +1,34 @@
+require 'test/unit'
+require 'mocha/minitest'
+require 'fileutils'
+
+class SignalTest < Test::Unit::TestCase
+  CMD     = File.expand_path('../../bin/clockwork', __FILE__)
+  SAMPLE  = File.expand_path('../samples/signal_test.rb', __FILE__)
+  LOGFILE = File.expand_path('../tmp/signal_test.log', __FILE__)
+
+  setup do
+    FileUtils.mkdir_p(File.dirname(LOGFILE))
+    @pid = spawn(CMD, SAMPLE)
+    until File.exist?(LOGFILE)
+      sleep 0.1
+    end
+  end
+
+  teardown do
+    FileUtils.rm_r(File.dirname(LOGFILE))
+  end
+
+  test 'should gracefully shutdown with SIGTERM' do
+    Process.kill(:TERM, @pid)
+    sleep 0.2
+    assert_equal 'done', File.read(LOGFILE)
+  end
+
+  test 'should forcely shutdown with SIGINT' do
+    Process.kill(:INT, @pid)
+    sleep 0.2
+    assert_equal 'start', File.read(LOGFILE)
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clockwork
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 3.0.2
 platform: ruby
 authors:
 - Adam Wiggins
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-15 00:00:00.000000000 Z
+date: 2023-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tzinfo
@@ -39,20 +39,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -109,6 +95,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  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: A scheduler process to replace cron, using a more flexible Ruby syntax
   running as a single long-running process.  Inspired by rufus-scheduler and resque-scheduler.
 email:
@@ -121,8 +121,9 @@ extensions: []
 extra_rdoc_files:
 - README.md
 files:
+- ".github/workflows/tests.yml"
 - ".gitignore"
-- ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
@@ -132,8 +133,6 @@ files:
 - clockwork.gemspec
 - clockworkd.1
 - example.rb
-- gemfiles/activesupport3.gemfile
-- gemfiles/activesupport4.gemfile
 - lib/clockwork.rb
 - lib/clockwork/at.rb
 - lib/clockwork/database_events.rb
@@ -152,7 +151,9 @@ files:
 - test/database_events/test_helpers.rb
 - test/event_test.rb
 - test/manager_test.rb
-homepage: http://github.com/tomykaira/clockwork
+- test/samples/signal_test.rb
+- test/signal_test.rb
+homepage: http://github.com/Rykian/clockwork
 licenses:
 - MIT
 metadata: {}
@@ -171,8 +172,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: A scheduler process to replace cron.
@@ -185,3 +185,5 @@ test_files:
 - test/database_events/test_helpers.rb
 - test/event_test.rb
 - test/manager_test.rb
+- test/samples/signal_test.rb
+- test/signal_test.rb

data/.travis.yml

@@ -1,13 +0,0 @@
-language: ruby
-sudo: false
-cache: bundler
-rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1
-  - 2.2
-  - jruby-19mode
-  - # rbx-2.2.7
-gemfile:
-  - gemfiles/activesupport3.gemfile
-  - gemfiles/activesupport4.gemfile

data/gemfiles/activesupport3.gemfile

@@ -1,10 +0,0 @@
-source 'https://rubygems.org'
-
-platforms :rbx do
-  gem 'rubysl', '~> 2.0'
-  gem 'rubysl-test-unit'
-  gem 'rubinius-developer_tools'
-end
-
-gem 'activesupport', '~> 3.2.14'
-gemspec :path=>"../"

data/gemfiles/activesupport4.gemfile

@@ -1,11 +0,0 @@
-source 'https://rubygems.org'
-
-platforms :rbx do
-  gem 'rubysl', '~> 2.0'
-  gem 'rubysl-test-unit'
-  gem 'rubinius-developer_tools'
-end
-
-gem 'activesupport', '~> 4.0.0'
-gem 'minitest', '~> 4.2'
-gemspec :path=>"../"