rufus-scheduler 3.0.8 → 3.2.0

data/CHANGELOG.txt

@@ -2,6 +2,81 @@
 = rufus-scheduler CHANGELOG.txt
 
 
+== rufus-scheduler - 3.2.0    released 2015-12-28
+
+- cache CronLine#brute_frequency results, gh-188 and gh-89
+- "every" shift prevention by https://github.com/Korrigan
+- Ruby warnings silenced by https://github.com/vivitar
+
+
+== rufus-scheduler - 3.1.10    released 2015-11-18
+
+- allow for :first_in => 0, gh-179 by https://github.com/JonMcPherson
+  for https://github.com/Shopify/dashing/commit/ea3730fa4
+- stop shipping specs in gem
+
+
+== rufus-scheduler - 3.1.9    released 2015-11-12
+
+- fix potential RuntimeError in CronLine#prev_second,
+  by Alexandru https://github.com/alexandru-calinoiu
+
+
+== rufus-scheduler - 3.1.8    released 2015-11-10
+
+- stop jumping eagerly out of DST, fix for one hour jump when leaving DST
+  thanks Alyssa http://github.com/alyssa
+
+
+== rufus-scheduler - 3.1.7    released 2015-10-15
+
+- ack #unscheduled_at in #scheduled?, by Claude https://github.com/claudeatsafe
+
+
+== rufus-scheduler - 3.1.6    released 2015-10-01
+
+- fix job id uniqueness (JRuby), thanks 김성식 https://github.com/kssminus
+
+
+== rufus-scheduler - 3.1.5    released 2015-09-25
+
+- fix for "not a valid cronline" on "mingw" Ruby distributions, gh-166
+
+
+== rufus-scheduler - 3.1.4    released 2015/08/29
+
+- fix cron issue reported by Jesse https://github.com/jhw-at-prosperworks-com
+
+
+== rufus-scheduler - 3.1.3    released 2015/06/20
+
+- prevent Thread[:rufus_scheduler_time] -> nil, gh-156
+- fix inconsistency in Job#start_work_thread
+
+
+== rufus-scheduler - 3.1.2    released 2015/05/23
+
+- avoid cron/:first_at infinite loop, thanks https://github.com/pouellet
+
+
+== rufus-scheduler - 3.1.1    released 2015/04/19
+
+- fix ZoTime.is_timezone? on OSX, thanks https://github.com/yaauie
+
+
+== rufus-scheduler - 3.1.0    released 2015/04/18
+
+- go without tzinfo (and its dependencies)
+- include @ketan's #next_time improvements
+- remove 2.x warning message on install
+
+
+== rufus-scheduler - 3.0.9    released 2014/08/30
+
+- fix TZ with underscores, thanks https://github.com/gnilrets
+- integrate https://github.com/ecin Lock mecha
+
+
 == rufus-scheduler - 3.0.8    released 2014/06/09
 
 - handle TZInfo errors on DST transitions, thanks https://github.com/junhanamaki

data/CREDITS.txt

@@ -4,6 +4,21 @@
 
 == Contributors
 
+- Balasankar C (https://github.com/balasankarc) fix CronJob spec vs December
+- Matthieu Rosinski (https://github.com/Korrigan) prevent "every" shifts
+- vivitar (https://github.com/vivitar) silenced a set of Ruby warnings
+- Jon McPherson (https://github.com/JonMcPherson) :first_in => 0 back
+- Calinoiu Alexandru Nicolae (https://github.com/alexandru-calinoiu) CronLine#prev_second fix
+- Alyssa Pohahau (https://github.com/alyssa) out of DST transition specs
+- Claude Vessaz (https://github.com/claudeatsafe) ack #unscheduled_at in #scheduled?
+- 김성식 (https://github.com/kssminus) job id uniqueness effort
+- Jesse Willet (https://github.com/jhw-at-prosperworks-com) cron vs "*/10"
+- Pascal Ouellet (https://github.com/pouellet) Scheduler#timeline loop fix
+- Ryan Biesemeyer (https://github.com/yaauie) ZoTime.is_timezone? on OSX
+- Ketan Padegaonkar (https://github.com/ketan) .brute_frequency improvement
+- Gabriel Gilder (https://github.com/ggilder) LA DST specs
+- Sterling Paramore (https://github.com/gnilrets) underscore TZ fix
+- ecin (https://github.com/ecin) new lock mecha
 - Adam Jonas (https://github.com/adamjonas) migrate specs to "expect"
 - Yassen Bantchev (https://github.com/yassenb) CronLine#previous_time rewrite
 - Eric Lindvall (https://github.com/eric) Zookeeper locked example
@@ -31,6 +46,12 @@
 
 == Feedback
 
+- Eduardo Maia - https://github.com/emaiax - rufus and the Rails console
+- Suisea - https://github.com/suisea - readme rewording
+- Radek - http://stackoverflow.com/users/250422 - gh-166
+- Patrik Ragnarsson - https://github.com/dentarg - timeout vs nil, gh-156
+- twitter @adefilaedward1 - typo in readme
+- Michael Guymon - https://github.com/mguymon - #next_time vs :first_at
 - junhanamaki - https://github.com/junhanamaki - #next_time and dst ambiguities
 - kreynolds (tossrock) - inspiration for #occurrences
 - Matteo - https://github.com/m4ce - dst and cron issue

data/LICENSE.txt

@@ -1,5 +1,5 @@
 
-Copyright (c) 2005-2014, John Mettraux, jmettraux@gmail.com
+Copyright (c) 2005-2015, 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

data/README.md

@@ -61,6 +61,7 @@ It does not persist your schedules. When the process is gone and the scheduler i
 
 * [whenever](https://github.com/javan/whenever) - let cron call back your Ruby code, trusted and reliable cron drives your schedule
 * [clockwork](https://github.com/tomykaira/clockwork) - rufus-scheduler inspired gem
+* [crono](https://github.com/plashchynski/crono) - an in-Rails cron scheduler
 
 (please note: rufus-scheduler is not a cron replacement)
 
@@ -72,7 +73,12 @@ It's a complete rewrite of rufus-scheduler.
 There is no EventMachine-based scheduler anymore.
 
 
-## Notables changes:
+## I don't know what this Ruby thing is, where are my Rails?
+
+I'll drive you right to the [tracks](#so-rails).
+
+
+## Notable changes:
 
 * As said, no more EventMachine-based scheduler
 * ```scheduler.every('100') {``` will schedule every 100 seconds (previously, it would have been 0.1s). This aligns rufus-scheduler on Ruby's ```sleep(100)```
@@ -89,6 +95,8 @@ There is no EventMachine-based scheduler anymore.
 
 So you need help. People can help you, but first help them help you, and don't waste their time. Provide a complete description of the issue. If it works on A but not on B and others have to ask you: "so what is different between A and B" you are wasting everyone's time.
 
+"hello" and "thanks" are not swear words.
+
 Go read [how to report bugs effectively](http://www.chiark.greenend.org.uk/~sgtatham/bugs.html), twice.
 
 Update: [help_help.md](https://gist.github.com/jmettraux/310fed75f568fd731814) might help help you.
@@ -115,7 +123,8 @@ Yes, issues can be reported in [rufus-scheduler issues](https://github.com/jmett
 * [I want a refund](http://blog.nodejitsu.com/getting-refunds-on-open-source-projects)
 * [Passenger and rufus-scheduler](http://stackoverflow.com/questions/18108719/debugging-rufus-scheduler/18156180#18156180)
 * [Passenger and rufus-scheduler (2)](http://stackoverflow.com/questions/21861387/rufus-cron-job-not-working-in-apache-passenger#answer-21868555)
-* [Unicorn and rufus-scheduler](https://jkraemer.net/running-rufus-scheduler-in-a-unicorn-rails-app)
+* [The scheduler comes up when running the Rails console](https://github.com/jmettraux/rufus-scheduler#avoid-scheduling-when-running-the-ruby-on-rails-console)
+* [I don't get any of this, I just want it to work in my Rails application](#so-rails)
 
 
 ## scheduling
@@ -1097,6 +1106,57 @@ This is useful in environments where the Ruby process holding the scheduler gets
 
 If the lockfile mechanism here is not sufficient, you can plug your custom mechanism. It's explained in [advanced lock schemes](#advanced-lock-schemes) below.
 
+### :scheduler_lock
+
+(since rufus-scheduler 3.0.9)
+
+The scheduler lock is an object that responds to `#lock` and `#unlock`. The scheduler calls `#lock` when starting up. If the answer is `false`, the scheduler stops its initialization work and won't schedule anything.
+
+Here is a sample of a scheduler lock that only lets the scheduler on host "coffee.example.com" start:
+```ruby
+class HostLock
+  def initialize(lock_name)
+    @lock_name = lock_name
+  end
+  def lock
+    @lock_name == `hostname -f`.strip
+  end
+  def unlock
+    true
+  end
+end
+
+scheduler =
+  Rufus::Scheduler.new(:scheduler_lock => HostLock.new('coffee.example.com'))
+```
+
+By default, the scheduler_lock is an instance of `Rufus::Scheduler::NullLock`, with a `#lock` that returns true.
+
+### :trigger_lock
+
+(since rufus-scheduler 3.0.9)
+
+The trigger lock in an object that responds to `#lock`. The scheduler calls that method on the job lock right before triggering any job. If the answer is false, the trigger doesn't happen, the job is not done (at least not in this scheduler).
+
+Here is a (stupid) PingLock example, it'll only trigger if an "other host" is not responding to ping. Do not use that in production, you don't want to fork a ping process for each trigger attempt...
+```ruby
+class PingLock
+  def initialize(other_host)
+    @other_host = other_host
+  end
+  def lock
+    ! system("ping -c 1 #{@other_host}")
+  end
+end
+
+scheduler =
+  Rufus::Scheduler.new(:trigger_lock => PingLock.new('main.example.com'))
+```
+
+By default, the trigger_lock is an instance of `Rufus::Scheduler::NullLock`, with a `#lock` that always returns true.
+
+As explained in [advanced lock schemes](#advanced-lock-schemes), another way to tune that behaviour is by overriding the scheduler's `#confirm_lock` method. (You could also do that with an `#on_pre_trigger` callback).
+
 ### :max_work_threads
 
 In rufus-scheduler 2.x, by default, each job triggering received its own, brand new, thread of execution. In rufus-scheduler 3.x, execution happens in a pooled work thread. The max work thread count (the pool size) defaults to 28.
@@ -1183,6 +1243,20 @@ to make sure that the lock is still valid.
 
 The #confirm_lock method is called right before a job triggers (if it is provided). The more generic callback #on_pre_trigger is called right after #confirm_lock.
 
+### :scheduler_lock and :trigger_lock
+
+(introduced in rufus-scheduler 3.0.9).
+
+Another way of prodiving `#lock`, `#unlock` and `#confirm_lock` to a rufus-scheduler is by using the `:scheduler_lock` and `:trigger_lock` options.
+
+See [:trigger_lock](#trigger_lock) and [:scheduler_lock](#scheduler_lock).
+
+The scheduler lock may be used to prevent a scheduler from starting, while a trigger lock prevents individual jobs from triggering (the scheduler goes on scheduling).
+
+One has to be careful with what goes in `#confirm_lock` or in a trigger lock, as it gets called before each trigger.
+
+Warning: you may think you're heading towards "high availability" by using a trigger lock and having lots of schedulers at hand. It may be so if you limit yourself to scheduling the same set of jobs at scheduler startup. But if you add schedules at runtime, they stay local to their scheduler. There is no magic that propagates the jobs to all the schedulers in your pack.
+
 
 ## parsing cronlines and time strings
 
@@ -1303,19 +1377,6 @@ Rufus::Scheduler.parse("2013-12-12 14:00 Pacific/Saipan")
   # => 2013-12-12 04:00:00 UTC
 ```
 
-Behind the scenes, rufus-scheduler uses [tzinfo](http://tzinfo.github.io/) to deal with timezones.
-
-Here is a [list of timezones](misc/tz_all.txt) known to my Debian GNU/Linux 7. It was generated with this script:
-
-```ruby
-require 'tzinfo'
-TZInfo::Timezone.all.each { |tz| puts tz.name }
-```
-
-Unknown timezones, typos, will be rejected by tzinfo thus rufus-scheduler.
-
-On its own tzinfo derives the timezones from the system's information. On some system it needs some help, one can install the 'tzinfo-data' gem to provide the missing information.
-
 
 ## so Rails?
 
@@ -1339,6 +1400,7 @@ s = Rufus::Scheduler.singleton
 s.every '1m' do
 
   Rails.logger.info "hello, it's #{Time.now}"
+  Rails.logger.flush
 end
 ```
 
@@ -1367,6 +1429,49 @@ The rufus-scheduler singleton is instantiated in the ```config/initializers/sche
 
 *Warning*: this works well with single-process Ruby servers like Webrick and Thin. Using rufus-scheduler with Passenger or Unicorn requires a bit more knowledge and tuning, gently provided by a bit of googling and reading, see [Faq](#faq) above.
 
+### avoid scheduling when running the Ruby on Rails console
+
+(Written in reply to https://github.com/jmettraux/rufus-scheduler/issues/186 )
+
+If you don't want rufus-scheduler to kick in when running the Ruby on Rails console, you can wrap your initializer in a conditional:
+
+```ruby
+#
+# config/initializers/scheduler.rb
+
+require 'rufus-scheduler'
+
+s = Rufus::Scheduler.singleton
+
+
+unless defined?(Rails::Console)
+  # only schedule when not running from the Rails on Rails console
+
+  s.every '1m' do
+
+    Rails.logger.info "hello, it's #{Time.now}"
+    Rails.logger.flush
+  end
+end
+```
+
+It should work for Ruby on Rails 3 and 4.
+
+### rails server -d
+
+(Written in reply to https://github.com/jmettraux/rufus-scheduler/issues/165 )
+
+There is the handy `rails server -d` that starts a development Rails as a daemon. The annoying thing is that the scheduler as seen above is started in the main process that then gets forked and daemonized. The rufus-scheduler thread (and any other thread) gets lost, no scheduling happens.
+
+I avoid running `-d` in development mode and bother about daemonizing only for production deployment.
+
+These are two well crafted articles on process daemonization, please read them:
+
+* http://www.mikeperham.com/2014/09/22/dont-daemonize-your-daemons/
+* http://www.mikeperham.com/2014/07/07/use-runit/
+
+If, anyway, you need something like `rails server -d`, why not try `bundle exec unicorn -D` instead? In my (limited) experience, it worked out of the box (well, had to add `gem 'unicorn'` to `Gemfile` first).
+
 
 ## support