rufus-scheduler 3.0.8 → 3.1.0

data/CHANGELOG.txt

@@ -2,6 +2,19 @@
 = rufus-scheduler CHANGELOG.txt
 
 
+== 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,10 @@
 
 == Contributors
 
+- 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 +35,7 @@
 
 == Feedback
 
+- 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,6 +73,11 @@ It's a complete rewrite of rufus-scheduler.
 There is no EventMachine-based scheduler anymore.
 
 
+## I don't know what this Ruby thing is, where are my Rails?
+
+Sir, I'll drive you right to the [tracks](#so-rails).
+
+
 ## Notables changes:
 
 * As said, no more EventMachine-based scheduler
@@ -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.
@@ -1097,6 +1105,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 +1242,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 +1376,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?
 

data/lib/rufus/scheduler/cronline.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2006-2014, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2006-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
@@ -22,6 +22,8 @@
 # Made in Japan.
 #++
 
+require 'set'
+
 
 class Rufus::Scheduler
 
@@ -54,8 +56,7 @@ class Rufus::Scheduler
 
       items = line.split
 
-      @timezone = (TZInfo::Timezone.get(items.last) rescue nil)
-      items.pop if @timezone
+      @timezone = items.pop if ZoTime.is_timezone?(items.last)
 
       raise ArgumentError.new(
         "not a valid cronline : '#{line}'"
@@ -82,9 +83,7 @@ class Rufus::Scheduler
     #
     def matches?(time)
 
-      time = Time.at(time) unless time.kind_of?(Time)
-
-      time = @timezone.utc_to_local(time.getutc) if @timezone
+      time = ZoTime.new(time.to_f, @timezone || ENV['TZ']).time
 
       return false unless sub_match?(time, :sec, @seconds)
       return false unless sub_match?(time, :min, @minutes)
@@ -122,37 +121,34 @@ class Rufus::Scheduler
     #
     def next_time(from=Time.now)
 
-      time = local_time(from)
-      time = round_to_seconds(time)
-
-      # start at the next second
-      time = time + 1
+      time = nil
+      zotime = ZoTime.new(from.to_i + 1, @timezone || ENV['TZ'])
 
       loop do
+
+        time = zotime.time
+
         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...
+          zotime.add((24 - time.hour) * 3600 - time.min * 60 - time.sec)
           next
         end
         unless sub_match?(time, :hour, @hours)
-          time += (60 - time.min) * 60 - time.sec; next
+          zotime.add((60 - time.min) * 60 - time.sec)
+          next
         end
         unless sub_match?(time, :min, @minutes)
-          time += 60 - time.sec; next
+          zotime.add(60 - time.sec)
+          next
         end
         unless sub_match?(time, :sec, @seconds)
-          time += 1; next
+          zotime.add(next_second(time))
+          next
         end
 
         break
       end
 
-      global_time(time, from.utc?)
-
-    rescue TZInfo::PeriodNotFound
-
-      next_time(from + 3600)
+      time
     end
 
     # Returns the previous time the cronline matched. It's like next_time, but
@@ -160,35 +156,48 @@ class Rufus::Scheduler
     #
     def previous_time(from=Time.now)
 
-      time = local_time(from)
-      time = round_to_seconds(time)
-
-      # start at the previous second
-      time = time - 1
+      time = nil
+      zotime = ZoTime.new(from.to_i - 1, @timezone || ENV['TZ'])
 
       loop do
+
+        time = zotime.time
+
         unless date_match?(time)
-          time -= time.hour * 3600 + time.min * 60 + time.sec + 1; next
+          zotime.substract(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
+          zotime.substract(time.min * 60 + time.sec + 1)
+          next
         end
         unless sub_match?(time, :min, @minutes)
-          time -= time.sec + 1; next
+          zotime.substract(time.sec + 1)
+          next
         end
         unless sub_match?(time, :sec, @seconds)
-          time -= 1; next
+          zotime.substract(prev_second(time))
+          next
         end
 
         break
       end
 
-      global_time(time, from.utc?)
-
-    rescue TZInfo::PeriodNotFound
+      time
+    end
 
-      previous_time(time)
+    if RUBY_VERSION >= '1.9'
+      def toa(item)
+        item == nil ? nil : item.to_a
+      end
+    else
+      def toi(item); item.is_a?(String) ? item.hash.abs : item.to_i; end
+      protected :toi
+      def toa(item)
+        item.is_a?(Set) ? item.to_a.sort_by { |e| toi(e) } : item
+      end
     end
+    protected :toa
 
     # Returns an array of 6 arrays (seconds, minutes, hours, days,
     # months, weekdays).
@@ -197,14 +206,14 @@ class Rufus::Scheduler
     def to_array
 
       [
-        @seconds,
-        @minutes,
-        @hours,
-        @days,
-        @months,
-        @weekdays,
-        @monthdays,
-        @timezone ? @timezone.name : nil
+        toa(@seconds),
+        toa(@minutes),
+        toa(@hours),
+        toa(@days),
+        toa(@months),
+        toa(@weekdays),
+        toa(@monthdays),
+        @timezone
       ]
     end
 
@@ -212,7 +221,7 @@ class Rufus::Scheduler
     # 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
+    # examining a whole year, that can take more than seconds for a seconds
     # level cron...
     #
     def frequency
@@ -220,9 +229,10 @@ class Rufus::Scheduler
       return brute_frequency unless @seconds && @seconds.length > 1
 
       delta = 60
-      prev = @seconds[0]
+      secs = toa(@seconds)
+      prev = secs[0]
 
-      @seconds[1..-1].each do |sec|
+      secs[1..-1].each do |sec|
         d = sec - prev
         delta = d if d < delta
       end
@@ -270,7 +280,7 @@ class Rufus::Scheduler
         delta = d if d < delta
 
         break if @months == nil && t1.month == 2
-        break if t1.year == 2001
+        break if t1.year >= 2001
 
         t0 = t1
       end
@@ -280,6 +290,26 @@ class Rufus::Scheduler
 
     protected
 
+    def next_second(time)
+
+      secs = @seconds.sort
+
+      return secs.last + 60 - time.sec if time.sec > secs.last
+
+      secs.shift while secs.first < time.sec
+
+      secs.first - time.sec
+    end
+
+    def prev_second(time)
+
+      secs = @seconds.sort
+
+      secs.pop while time.sec < secs.last
+
+      time.sec - secs.last
+    end
+
     WEEKDAYS = %w[ sun mon tue wed thu fri sat ]
     DAY_S = 24 * 3600
     WEEK_S = 7 * DAY_S
@@ -336,7 +366,7 @@ class Rufus::Scheduler
         "found duplicates in #{item.inspect}"
       ) if r.uniq.size < r.size
 
-      r
+      Set.new(r)
     end
 
     RANGE_REGEX = /^(\*|\d{1,2})(?:-(\d{1,2}))?(?:\/(\d{1,2}))?$/
@@ -435,32 +465,6 @@ class Rufus::Scheduler
 
       [ "#{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/rufus/scheduler/job_array.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2006-2014, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2006-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
@@ -22,6 +22,7 @@
 # Made in Japan.
 #++
 
+
 module Rufus
 
   class Scheduler

data/lib/rufus/scheduler/jobs.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2006-2014, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2006-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
@@ -117,15 +117,16 @@ module Rufus
 
       def trigger(time)
 
-        set_next_time(false, time)
+        set_next_time(time)
 
-        return if opts[:overlap] == false && running?
-
-        r =
+        return if (
+          opts[:overlap] == false &&
+          running?
+        )
+        return if (
           callback(:confirm_lock, time) &&
           callback(:on_pre_trigger, time)
-
-        return if r == false
+        ) == false
 
         @count += 1
 
@@ -272,7 +273,7 @@ module Rufus
 
       def post_trigger(time)
 
-        set_next_time(true, time)
+        set_next_time(time, true)
 
         callback(:on_post_trigger, time)
       end
@@ -339,7 +340,7 @@ module Rufus
 
       def occurrences(time0, time1)
 
-        time >= time0 && time <= time1 ? [ time ] : []
+        (time >= time0 && time <= time1) ? [ time ] : []
       end
 
       protected
@@ -356,7 +357,7 @@ module Rufus
 
       # There is no next_time for one time jobs, hence the false.
       #
-      def set_next_time(is_post, trigger_time)
+      def set_next_time(trigger_time, is_post=false)
 
         @next_time = is_post ? nil : false
       end
@@ -408,15 +409,17 @@ module Rufus
         self.first_at =
           opts[:first] || opts[:first_time] ||
           opts[:first_at] || opts[:first_in] ||
-          0
+          nil
         self.last_at =
           opts[:last] || opts[:last_at] || opts[:last_in]
       end
 
       def first_at=(first)
 
+        return @first_at = nil if first == nil
+
         n = Time.now
-        first = n + 0.001 if first == :now || first == :immediately
+        first = n + 0.003 if first == :now || first == :immediately
 
         @first_at = Rufus::Scheduler.parse_to_time(first)
 
@@ -439,9 +442,6 @@ module Rufus
       def trigger(time)
 
         return if @paused_at
-        return if time < @first_at
-          #
-          # TODO: remove me when @first_at gets reworked
 
         return (@next_time = nil) if @times && @times < 1
         return (@next_time = nil) if @last_at && time >= @last_at
@@ -527,20 +527,18 @@ module Rufus
           "of #{@frequency.inspect} (#{@original.inspect})"
         ) if @frequency <= 0
 
-        set_next_time(false, nil)
+        set_next_time(nil)
       end
 
       protected
 
-      def set_next_time(is_post, trigger_time)
+      def set_next_time(trigger_time, is_post=false)
 
         return if is_post
 
         @next_time =
-          if trigger_time
-            trigger_time + @frequency
-          elsif @first_at < Time.now
-            Time.now + @frequency
+          if @first_at == nil || @first_at < Time.now
+            (trigger_time || Time.now) + @frequency
           else
             @first_at
           end
@@ -567,18 +565,18 @@ module Rufus
           "of #{@interval.inspect} (#{@original.inspect})"
         ) if @interval <= 0
 
-        set_next_time(false, nil)
+        set_next_time(nil)
       end
 
       protected
 
-      def set_next_time(is_post, trigger_time)
+      def set_next_time(trigger_time, is_post=false)
 
         @next_time =
           if is_post
             Time.now + @interval
           elsif trigger_time.nil?
-            if @first_at < Time.now
+            if @first_at == nil || @first_at < Time.now
               Time.now + @interval
             else
               @first_at
@@ -601,7 +599,7 @@ module Rufus
         super(scheduler, cronline, opts, block)
 
         @cron_line = opts[:_t] || CronLine.new(cronline)
-        @next_time = @cron_line.next_time
+        set_next_time(nil)
       end
 
       def frequency
@@ -616,14 +614,18 @@ module Rufus
 
       protected
 
-      def set_next_time(is_post, trigger_time)
+      def set_next_time(trigger_time, is_post=false)
 
-        @next_time = @cron_line.next_time
+        @next_time = next_time_from(trigger_time || Time.now)
       end
 
       def next_time_from(time)
 
-        @cron_line.next_time(time)
+        if @first_at == nil || @first_at < time
+          @cron_line.next_time(time)
+        else
+          @first_at
+        end
       end
     end
   end